private void RecordResponse()
{
TrackingRequest request = _repository.GetLastTrackingRequest(_person.PersonId);
if (request != null)
{
TextMessageParser parser = new TextMessageParser(_body, _person.PersonId, _repository.GetMealType(request.TrackingRequestId).MealTypeId);
if (parser.ExerciseRecord != null)
{
_repository.Exercise.Add(parser.ExerciseRecord);
}
if (parser.NutritionRecord != null)
{
_repository.NutritionHistory.Add(parser.NutritionRecord);
}
if (parser.WeightRecord != null)
{
_repository.WeightHistory.Add(parser.WeightRecord);
}
TrackingResponse response = new TrackingResponse();
response.TrackingRequestId = request.TrackingRequestId;
response.ResponseText = parser.ResponseText;
_repository.TrackingResponses.Add(response);
_repository.SaveChanges();
_result = _repository.DATA_SAVED_TXT_MSG;
}
}
/// <summary>
/// 物流跟踪
/// </summary>
/// <param name="rateRequest"></param>
/// <returns></returns>
public static TrackingResponse GetTracking(TrackingRequest rateRequest)
{
var request = new Request("api/Tracking");
var result = request.Execute(rateRequest);
return(XmlUtilHelper.DeSerializedEntity <TrackingResponse>(result));
}
/// <summary>
/// Builds the tracking request from a Google Event.
/// </summary>
/// <param name="googleEvent">The google event.</param>
/// <returns></returns>
public TrackingRequest BuildRequest(GaDotNet.Common.Data.GoogleEvent googleEvent)
{
var r = new TrackingRequest();
r.AnalyticsAccountCode = ConfigurationSettings.GoogleAccountCode;
r.TrackingEvent = googleEvent;
return(r);
}
/// <summary>
/// Builds the tracking request from a Google Transaction.
/// </summary>
/// <param name="googleTransaction">The google transaction.</param>
/// <returns></returns>
public TrackingRequest BuildRequest(GaDotNet.Common.Data.GoogleTransaction googleTransaction)
{
var r = new TrackingRequest();
r.AnalyticsAccountCode = ConfigurationSettings.GoogleAccountCode;
r.TrackingTransaction = googleTransaction;
return(r);
}
/// <summary>
/// Gets the tracking by the tracking code asynchronous.
/// </summary>
/// <param name="trackingCode">The tracking code.</param>
/// <param name="token">The cancellation token.</param>
/// <returns>A task of <see cref="TrackingResponse"/></returns>
public async Task <TrackingResponse> GetTrackingAsync(string trackingCode, CancellationToken token)
{
var data = new TrackingRequest
{
Token = _token,
TrackingCode = trackingCode
};
return(await _service.Get <TrackingResponse, TrackingRequest>(data, token).ConfigureAwait(_configureAwait));
}
/// <summary>
/// Fires the tracking event with Google Analytics
/// </summary>
/// <param name="request">The request.</param>
public static void FireTrackingEvent(TrackingRequest request)
{
//send the request to google
WebRequest requestForGaGif = WebRequest.Create(request.TrackingGifUri);
using (WebResponse response = requestForGaGif.GetResponse())
{
//ignore response
}
}
/// <summary>
/// Builds the tracking request.
/// </summary>
/// <param name="context">The HTTP context.</param>
/// <param name="urlToTrack">The URL to track.</param>
/// <returns></returns>
public TrackingRequest BuildRequest(HttpContext context)
{
var r = new TrackingRequest();
r.PageTitle = context.Request.QueryString["pagetitle"];
r.PageDomain = context.Request.QueryString["domain"];
r.AnalyticsAccountCode = context.Request.QueryString["ua"] ?? ConfigurationSettings.GoogleAccountCode;
r.PageUrl = context.Request.QueryString["url"];
return(r);
}
/// <summary>
/// Builds the request from a page view request and the appSettings 'GoogleAnalyticsAccountCode'
/// </summary>
/// <param name="pageView">The page view.</param>
/// <returns></returns>
public TrackingRequest BuildRequest(GaDotNet.Common.Data.GooglePageView pageView)
{
var r = new TrackingRequest();
r.PageTitle = pageView.PageTitle;
r.PageDomain = pageView.DomainName;
r.AnalyticsAccountCode = ConfigurationSettings.GoogleAccountCode;
r.PageUrl = pageView.Url;
return(r);
}
//TEST SET UP: This method will find the phoneNumber specified and will create numberOfRequests
//for that phone number. These requests will have no TrackingResponses associated with them
public static void CreateTrackingRequests(string phoneNumber, int numberOfRequests)
{
using (UGFContext db = new UGFContext())
{
Person p = db.FindPersonByPhoneNumber(phoneNumber);
if (p == null)
{
throw new Exception("Unable to find person with phonenumber: " + phoneNumber);
}
DateTime backDate = (DateTime.Now - new TimeSpan(((int)numberOfRequests / 3) + 2, 0, 0, 0)).ToShortDateString().ToDate();
if (p.CreatedDate > backDate)
{
p.CreatedDate = backDate;
p.ResumedDate = "";
db.SaveChanges();
}
IEnumerable <UserSchedule> schedules = p.UserSchedules;
int currentCount = 0;
while (backDate <= DateTime.Now)
{
foreach (UserSchedule s in schedules.OrderBy(t => t.OverrideUTCTimeOfDayToSend))
{
backDate = backDate.SetTimeOfDay(s.OverrideUTCTimeOfDayToSend.ToShortTimeString());
string text = s.SourceSchedule.ReferenceText;
TrackingRequest request = new TrackingRequest()
{
PersonId = p.PersonId, DateSent = backDate, TextSent = text, UserScheduleId = s.UserScheduleId
};
db.TrackingReqeusts.Add(request);
currentCount += 1;
if (currentCount >= numberOfRequests)
{
backDate = DateTime.Now;
break;
}
}
backDate = backDate.AddDays(1);
}
db.SaveChanges();
}
}
public async Task <IHttpActionResult> PostSearch(BaseRequest req)
{
try
{
if (!RequestHelper.VerifyRequest(req, "tracking"))
{
throw new Exception();
}
var search = JsonConvert.DeserializeObject <TrackingSearch>(req.Request.ToString());
var factory = Repository.GetFactory(search.FactoryId);
var response = await TrackingRequest.GetResponseAsync(search.Code, factory);
Repository.AddAction(search.Code, factory.Id, response.Status, req.Device.Id);
if (!response.Status)
{
var message = new Model.Message();
message.Title = "Bulunamadı";
message.Content = "Aradığınız kod ile eşleşen sonuç bulunamadı veya bir sorun oluştu.\nSorunu çözmeye çalışacağız.";
message.Type = "raw";
message.Buttons = new List <Model.MessageButton>()
{
new Model.MessageButton("Tekrar dene", "track(" + search.FactoryId + ", " + search.Code + ")"),
new Model.MessageButton("Daha Sonra", "closeMessage()")
};
}
return(Json(response));
}
catch (Exception)
{
var message = new Model.Message();
message.Title = "Bir sorun oluştu.";
message.Content = "Lütfen daha sonra tekrar deneyiniz.";
message.Type = "raw";
message.Buttons = new List <Model.MessageButton>()
{
new Model.MessageButton("Tamam", "closeMessage()")
};
return(Json(new BaseResponse()
{
Status = false, Message = message
}));
}
}
/// <summary>
/// Fires the tracking event with Google Analytics
/// </summary>
/// <param name="request">The request.</param>
public static void FireTrackingEvent(TrackingRequest request)
{
WebRequest requestForGaGif = WebRequest.Create(request.TrackingGifUri);
requestForGaGif.BeginGetResponse(r =>
{
try
{
var reponse = requestForGaGif.EndGetResponse(r);
//ignore response
}
catch
{
//suppress error
}
}, null);
}
public void GetTrackingTest()
{
try
{
var request = new TrackingRequest()
{
TrackNo = "9400110205425007474346",
LogisticsCode = ShippingClassEnum.Usps.ToString()
};
var result = PostponyApiService.GetTracking(request);
Assert.AreEqual(result.Sucess, true);
}
catch (Exception ex)
{
throw;
}
}
public string CreateTrackingRequest(string userName, string pwd, DateTime clientLocalTime, Guid personId, string textSent, Guid userScheduleId)
{
if (ValidateUsernamePwd(userName, pwd))
{
try
{
TrackingRequest tr = new TrackingRequest()
{
DateSent = clientLocalTime, PersonId = personId, TextSent = textSent, UserScheduleId = userScheduleId
};
_repository.TrackingReqeusts.Add(tr);
_repository.SaveChanges();
return("OK");
}
catch (Exception exp)
{
return(ExceptionToString(exp));
}
}
return("Invalid usename and/or pwd");
}
public List <TextToSend> SendScheduledTexts(IScheduleTextHandler handler)
{
if (handler == null)
{
handler = new uGitFitDefaultHandler();
}
List <TextToSend> rtnVal = this.GetScheduledTextsNeedingToBeSent(true);
foreach (TextToSend txt in rtnVal)
{
TrackingRequest tr = new TrackingRequest()
{
DateSent = txt.CurrentLocalTime, PersonId = txt.PersonId, TextSent = txt.TranslatedText, UserScheduleId = txt.UserScheduleId
};
_repository.TrackingReqeusts.Add(tr);
_repository.SaveChanges();
handler.SendUserText(txt);
}
return(rtnVal);
}
public async Task <IActionResult> Get(long startFrom, long endBy, int pageNo = 0, int pageSize = 10)
{
//call mediator
var request = new TrackingRequest(
ControllerContext, new TrackingFilter
{
StartFromTime = startFrom,
EndByTime = endBy,
PageNo = pageNo,
rowsCount = pageSize
},
_redisCache,
_messageQuery,
_middlewareConfiguration,
_correlationId,
_opertationalUnit
);
var result = await _mediator.Send(request);
//transform the result model
var trackingResult = result?.Select(t => new TrackingResponse(t));
return(new JsonResult(trackingResult));
}
public async Task <ActionResult> TrackPackages([FromServices] TrackingClient trackingClient, [FromBody, Required] TrackingRequest trackingRequest)
{
return(Ok(await trackingClient.TrackPackagesAsync(trackingRequest, Request.Headers["X-Vtex-Credential"])));
}
/// <summary>
/// Метод позволяет просматривать более расширенную информацию по статусу отправления.
/// При введенном номере телефона можно получить следующую информацию:
/// данные отправителя или получателя, номер телефона.
/// Метод позволяет просматривать одновременно до 100 отправлений.
/// </summary>
/// <param name="properties">Свойства метода.</param>
/// <returns>Ответ от API новой почты.</returns>
public Task <ApiResponse <Tracking> > GetTrackingDocumentsAsync(TrackingRequest properties)
{
var request = _creator.CreateGetTrackings(_config.ApiKey, properties);
return(_client.RequestForResponseAsync <Tracking>(request));
}
public ApiRequest CreateGetTrackings(string apiKey, TrackingRequest properties) => CreateRequest(apiKey, "TrackingDocument", "getStatusDocuments", properties);
public async Task <List <PackageHistory> > TrackPackagesAsync(TrackingRequest trackingRequest, string authToken)
{
var packageHistory = new List <PackageHistory>();
var myCustomParameter = trackingRequest.Config["myCustomParameter"];
foreach (var package in trackingRequest.Packages)
{
var baseUrl = $"tracking-sandbox.getsandbox.com";
var parameters = $"/trackPackages?myCustomParameter={myCustomParameter}&tracking-number={package.TrackingNumber}&invoice-number={package.InvoiceNumber}";
var httpUrl = $"http://{baseUrl}{parameters}";
var httpsUrl = $"https://{baseUrl}{parameters}";
using (var request = new HttpRequestMessage
{
Method = HttpMethod.Get, //HttpMethod.Post if needed
RequestUri = new Uri(httpUrl)
})
{
request.Headers.Add("X-Vtex-Proxy-To", httpsUrl);
request.Headers.Add("Proxy-Authorization", authToken);
using (var response = await _httpClient.SendAsync(request))
{
var responseString = await response.Content.ReadAsStringAsync();
//Console.WriteLine(responseString);
var resultObject = JsonConvert.DeserializeObject <JToken>(responseString, _jsonSerializerSettings);
var trackingHistory = new TrackingHistory
{
Returned = false,
Delivered = false,
Events = new List <EventTrackingData>()
};
//Parse result and return correspondent tracking history
if (resultObject?["events"] is JArray eventsArray)
{
foreach (var item in eventsArray)
{
trackingHistory.Events.Add(new EventTrackingData
{
City = item["city"].ToString(),
State = item["state"].ToString(),
Description = item["description"].ToString(),
Date = DateTime.Parse(item["date"].ToString())
// DateTime.ParseExact(item["date"].ToString(), "dd-MM-yyyy HH:mm:ss", CultureInfo.InvariantCulture),
});
if (item["delivered"].ToObject <bool>())
{
trackingHistory.Delivered = true;
}
}
}
packageHistory.Add(new PackageHistory
{
Package = package,
TrackingHistory = trackingHistory
});
}
}
}
return(packageHistory);
}
static void Main(string[] args)
{
#region Example program setup
SetupConfigProvider();
SetupApiKey();
#endregion
#region ConfigureFramework
var sandbox = new Session()
{
EndPoint = "https://api-sandbox.pitneybowes.com", Requester = new ShippingApiHttpRequest()
};
// Initialize framework
// Hook in your concrete classes
Model.RegisterSerializationTypes(sandbox.SerializationRegistry);
// Hook in your config provider
sandbox.GetConfigItem = (s) => Configuration[s];
// Hook in your logger
sandbox.LogWarning = (s) => Logger.LogWarning(s);
sandbox.LogError = (s) => Logger.LogError(s);
sandbox.LogConfigError = (s) => Logger.LogCritical(s);
sandbox.LogDebug = (s) => Logger.LogInformation(s);
// Hook in your secure API key decryption
sandbox.GetApiSecret = GetApiKey;
if (Configuration["Mock"] == "true")
{
sandbox.Requester = new ShippingAPIMock();
}
Globals.DefaultSession = sandbox;
#endregion
#region CreateShipment
try
{
// Create shipment
var shipment = ShipmentFluent <Shipment> .Create()
.ToAddress((Address)AddressFluent <Address> .Create()
.AddressLines("643 Greenway RD")
.PostalCode("28607")
.CountryCode("US")
.Verify() // calls the service for address validation - will populate city and state from the zip
)
.MinimalAddressValidation("true")
//.ShipperRatePlan(Globals.DefaultSession.GetConfigItem("RatePlan")) // use if you have a custom rate plan
.FromAddress((Address)AddressFluent <Address> .Create()
.Company("Pitney Bowes Inc.")
.AddressLines("27 Waterview Drive")
.Residential(false)
.CityTown("Shelton")
.StateProvince("CT")
.PostalCode("06484")
.CountryCode("US")
.Person("Paul Wright", "203-555-1213", "*****@*****.**")
)
.Parcel((Parcel)ParcelFluent <Parcel> .Create()
.Dimension(12, 12, 10)
.Weight(16m, UnitOfWeight.OZ)
)
.Rates(RatesArrayFluent <Rates> .Create()
.USPSPriority <Rates, Parameter>()
.InductionPostalCode("06484")
)
.Documents((List <IDocument>)DocumentsArrayFluent <Document> .Create()
.ShippingLabel(ContentType.BASE64, Size.DOC_4X6, FileFormat.ZPL2)
)
.ShipmentOptions(ShipmentOptionsArrayFluent <ShipmentOptions> .Create()
.ShipperId(sandbox.GetConfigItem("ShipperID"))
.AddToManifest()
)
.TransactionId(Guid.NewGuid().ToString().Substring(15));
var label = Api.CreateShipment((Shipment)shipment).GetAwaiter().GetResult();
#endregion
#region UseShipment
if (label.Success)
{
Console.WriteLine(label.APIResponse.ParcelTrackingNumber);
// Tracking
var trackingRequest = new TrackingRequest
{
Carrier = Carrier.USPS,
TrackingNumber = label.APIResponse.ParcelTrackingNumber
};
var trackingResponse = Api.Tracking <TrackingStatus>(trackingRequest).GetAwaiter().GetResult();
// Parcel Reprint
var reprintRequest = new ReprintShipmentRequest()
{
Shipment = label.APIResponse.ShipmentId
};
var reprintResponse = Api.ReprintShipment <Shipment>(reprintRequest).GetAwaiter().GetResult();
// Write the label to disk
foreach (var d in reprintResponse.APIResponse.Documents)
{
if (d.ContentType == ContentType.BASE64 && d.FileFormat == FileFormat.PNG)
{
// Multiple page png document
Api.WriteToStream(d, null,
(stream, page) => // callback for each page
{
// create a new file
if (stream != null)
{
stream.Dispose();
}
string fileName = string.Format("{0}{1}p{2}.{3}", Path.GetTempPath(), reprintResponse.APIResponse.ShipmentId, page.ToString(), d.FileFormat.ToString());
Console.WriteLine("Document written to " + fileName);
return(new FileStream(fileName, FileMode.OpenOrCreate));
},
disposeStream: true
).GetAwaiter().GetResult();
}
else
{
string fileName = string.Format("{0}{1}.{2}", Path.GetTempPath(), reprintResponse.APIResponse.ShipmentId, d.FileFormat.ToString());
using (StreamWriter sw = new StreamWriter(fileName))
{
Api.WriteToStream(d, sw.BaseStream).GetAwaiter().GetResult();
Console.WriteLine("Document written to " + fileName);
}
}
}
}
#endregion
#region CreateManifest
// Create the manifest
var manifest = ManifestFluent <Manifest> .Create()
.Carrier(Carrier.USPS)
.FromAddress(((Shipment)shipment).FromAddress)
.InductionPostalCode("06484")
.SubmissionDate(DateTime.Now)
.AddParameter <Parameter>(ManifestParameter.SHIPPER_ID, sandbox.GetConfigItem("ShipperID"))
.TransactionId(Guid.NewGuid().ToString().Substring(15));
var manifestResponse = Api.CreateManifest <Manifest>(manifest).GetAwaiter().GetResult();
#endregion
#region UseManifest
if (manifestResponse.Success)
{
foreach (var d in manifestResponse.APIResponse.Documents)
{
string fileName = string.Format("{0}{1}.{2}", Path.GetTempPath(), manifestResponse.APIResponse.ManifestId, d.FileFormat.ToString());
try
{
using (StreamWriter sw = new StreamWriter(fileName))
{
Api.WriteToStream(d, sw.BaseStream).GetAwaiter().GetResult();
Console.WriteLine("Document written to " + fileName);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
#endregion
#region SchedulePickup
// Schedule a pickup
var pickup = PickupFluent <Pickup> .Create()
.Carrier(Carrier.USPS)
.PackageLocation(PackageLocation.MailRoom)
.PickupAddress(((Shipment)shipment).FromAddress)
.PickupDate(DateTime.Now.AddDays(1))
.AddPickupSummary <PickupCount, ParcelWeight>(PickupService.PM, 1, 16M, UnitOfWeight.OZ)
.TransactionId(Guid.NewGuid().ToString().Substring(15));
var pickupResponse = Api.Schedule <Pickup>(pickup).GetAwaiter().GetResult();
#endregion
#region UsePickup
// Cancel pickup
if (pickupResponse.Success)
{
pickup.Cancel();
}
// Cancel the label
if (label.Success)
{
var cancelRequest = new CancelShipmentRequest
{
Carrier = Carrier.USPS,
CancelInitiator = CancelInitiator.SHIPPER,
TransactionId = Guid.NewGuid().ToString().Substring(15),
ShipmentToCancel = label.APIResponse.ShipmentId
};
var cancelResponse = Api.CancelShipment(cancelRequest).GetAwaiter().GetResult();
}
#endregion
#region TransactionReports
// Transaction report with IEnumerable
var transactionsReportRequest = new ReportRequest()
{
FromDate = DateTimeOffset.Parse("6/30/2019"),
ToDate = DateTimeOffset.Now,
DeveloperId = sandbox.GetConfigItem("DeveloperID")
};
foreach (var t in TransactionsReport <Transaction> .Report(transactionsReportRequest, x => x.CreditCardFee == null || x.CreditCardFee > 10.0M, maxPages: 2))
{
Console.WriteLine(t.DestinationAddress);
}
// Transaction report with LINQ
TransactionsReport <Transaction> report = new TransactionsReport <Transaction>(sandbox.GetConfigItem("DeveloperID"), maxPages: 2);
var query = from transaction in report
where transaction.TransactionDateTime >= DateTimeOffset.Parse("6/30/2019") && transaction.TransactionDateTime <= DateTimeOffset.Now && transaction.TransactionType == TransactionType.POSTAGE_PRINT
select new { transaction.TransactionId };
foreach (var obj in query)
{
Console.WriteLine(obj);
}
#endregion
#region CarrierRules
// Download the carrier rules
var req = new RatingServicesRequest()
{
Carrier = Carrier.USPS,
OriginCountryCode = "US",
DestinationCountryCode = "US"
};
var res = CarrierRulesMethods.RatingServices(req).GetAwaiter().GetResult();
if (res.Success)
{
// validate a shipment
var v = new ShipmentValidator();
if (!v.Validate((Shipment)shipment, res.APIResponse))
{
Console.WriteLine("Shipment is not valid: {0}", v.Reason);
}
// do some interesting things with the rules
var ruleRep = new RuleReport
{
CarrierRules = new CarrierRule[1] {
res.APIResponse
}
};
// find possible services to fit a parcel
var to = ((Shipment)shipment).ToAddress;
var from = ((Shipment)shipment).FromAddress;
var parcel = ((Shipment)shipment).Parcel;
// match countries
ruleRep.CarrierRuleFilter = (rule) => rule.OriginCountry == from.CountryCode && rule.DestinationCountry == to.CountryCode;
// make sure parcel fits, is trackable and supports insurance, commercial base pricing
ruleRep.ParcelTypeRuleFilter = (rule) =>
rule.FitsDimensions(parcel.Dimension) &&
rule.HoldsWeight(parcel.Weight) &&
!(rule.Trackable == Trackable.NON_TRACKABLE) &&
rule.SpecialServiceRules.ContainsKey(SpecialServiceCodes.Ins) &&
rule.RateTypeId == "CONTRACT_RATES";
Shipment cheapestOption = null;
foreach (var ruleItem in ruleRep)
{
// create the shipment from looked up values
var newShipment = ShipmentFluent <Shipment> .Create()
.ToAddress(to)
.FromAddress(from)
.MinimalAddressValidation("true")
//.ShipperRatePlan(Globals.DefaultSession.GetConfigItem("RatePlan"))
.Parcel(parcel)
.Rates(RatesArrayFluent <Rates> .Create()
.Add()
.RateFromRule(ruleItem.Item1, ruleItem.Item2, ruleItem.Item3)
.SpecialServiceFromRule <Rates, SpecialServices>(ruleItem.Item4)
.SuggestedTrackingServiceFromRule <Rates, SpecialServices>(ruleItem.Item3)
.InductionPostalCode(from.PostalCode)
)
.Documents((List <IDocument>)DocumentsArrayFluent <Document> .Create()
.ShippingLabel()
)
.ShipmentOptions(ShipmentOptionsArrayFluent <ShipmentOptions> .Create()
.ShipperId(sandbox.GetConfigItem("ShipperID"))
.AddToManifest()
)
.TransactionId(Guid.NewGuid().ToString().Substring(15));
// rate the parcel
var ratesResponse = Api.Rates <Shipment>((Shipment)newShipment).GetAwaiter().GetResult();
if (ratesResponse.Success)
{
if (cheapestOption == null || ratesResponse.APIResponse.Rates.First().TotalCarrierCharge < cheapestOption.Rates.First().TotalCarrierCharge)
{
cheapestOption = ratesResponse.APIResponse;
}
Console.WriteLine("{0},{1},{2},{3},{4},{5},{6} --- ${7}",
ruleItem.Item1.Carrier,
ruleItem.Item1.OriginCountry,
ruleItem.Item1.DestinationCountry,
ruleItem.Item2.ServiceId,
ruleItem.Item3.ParcelType,
ruleItem.Item3.RateTypeId,
ruleItem.Item4 == null ? String.Empty : ruleItem.Item4.SpecialServiceId.ToString(),
ratesResponse.APIResponse.Rates.First().TotalCarrierCharge);
}
}
//get the label
cheapestOption.TransactionId = Guid.NewGuid().ToString().Substring(15);
var newLabel = Api.CreateShipment(cheapestOption).GetAwaiter().GetResult();
if (newLabel.Success)
{
string fileName = string.Format("{0}{1}.{2}", Path.GetTempPath(), newLabel.APIResponse.ShipmentId, "PDF");
using (StreamWriter sw = new StreamWriter(fileName))
{
Api.WriteToStream(newLabel.APIResponse.Documents.First(), sw.BaseStream).GetAwaiter().GetResult();
Console.WriteLine("Document written to " + fileName);
}
}
}
foreach (var u in sandbox.Counters.Keys)
{
Console.WriteLine(u);
Console.WriteLine("Errors: {0}", sandbox.Counters[u].ErrorCount);
foreach (var b in sandbox.Counters[u].CallHistogram.Keys)
{
Console.WriteLine("{0} {1}", 10 * b, sandbox.Counters[u].CallHistogram[b]);
}
}
}
catch (ShippingAPIException e)
{
Console.WriteLine("ShippingAPI exception" + e.Message);
if (e.ErrorResponse != null && e.ErrorResponse.Errors != null)
{
foreach (var l in e.ErrorResponse.Errors)
{
Console.WriteLine(l.ErrorCode + " " + l.Message);
}
}
}
#endregion
}
/// <summary>
/// The main entry point for the application.
/// </summary>
public void cmdTrack_Click(object sender, System.EventArgs e)
{
AccessRequest ar;
TrackingRequest tr;
TrackingResponse trackResponse;
tr = new TrackingRequest(txtTrackingNumber.Text, "1");
ar = new AccessRequest(LicenseNumber, UserName, Password);
trackResponse = tr.MakeRequest(ar);
txtType.Text = "Package";
if (trackResponse.MyResponse.ResponseStatusCode == 0)
{
MessageBox.Show("No Activity Information From UPS");
this.Close();
return;
}
if (trackResponse.MyShipment.MyPackage.Activity[0].Status.MyStatusType.Code == "X")
{
lbDelivery.Text = "Rescheduled Delivery:";
txtSchDelivery.Text = trackResponse.MyShipment.MyPackage.RescheduledDeliveryDate.ToString();
lbReference.Visible = false;
txtReference.Visible = false;
txtStatus1.Text = "Exception";
txtShipTo.Text = trackResponse.MyShipment.MyShipTo.DestAddress.AddressLine1 + "\n" +
trackResponse.MyShipment.MyShipTo.DestAddress.City + " " +
trackResponse.MyShipment.MyShipTo.DestAddress.StateProvinceCode;
txtBilledOn.Text = trackResponse.MyShipment.MyPackage.Activity[trackResponse.MyShipment.MyPackage.Activity.Length - 1].Timestamp.ToString();
//Reference ?
lbReference.Visible = true;
txtReference.Enabled = false;
txtReference.Visible = true;
txtReference.Text = trackResponse.MyShipment.MyPackage.MyReferenceNumbers[trackResponse.MyShipment.MyPackage.MyReferenceNumbers.Length - 1].Value.ToString();
}
else if (trackResponse.MyShipment.MyPackage.Activity[0].Status.MyStatusType.Code == "D")
{
lbShippedSigned.Text = "Signed By:";
txtBilledOn.Text = trackResponse.MyShipment.MyPackage.Activity[0].Location.SignedFor;
lbTo.Text = "Delivered To:";
txtShipTo.Text = trackResponse.MyShipment.MyShipTo.DestAddress.AddressLine1 + "\n" +
trackResponse.MyShipment.MyShipTo.DestAddress.City + " " +
trackResponse.MyShipment.MyShipTo.DestAddress.StateProvinceCode;
lbDelivery.Text = "Delivered On:";
txtSchDelivery.Text = trackResponse.MyShipment.MyPackage.Activity[0].Timestamp.ToString();
txtStatus1.Text = "Delivered";
}
else
{
if (trackResponse.MyShipment.MyPackage.Message != null)
{
txtStatus1.Text = trackResponse.MyShipment.MyPackage.Message.Description + "-";
}
txtStatus1.Text += trackResponse.MyShipment.MyPackage.Activity[0].Status.MyStatusType.Description.ToLower();
txtSchDelivery.Text = trackResponse.MyShipment.ScheduledDeliveryDate.ToString();
try
{
txtShipTo.Text = trackResponse.MyShipment.MyShipTo.DestAddress.AddressLine1 + "\n" +
trackResponse.MyShipment.MyShipTo.DestAddress.City + " " +
trackResponse.MyShipment.MyShipTo.DestAddress.StateProvinceCode;
txtBilledOn.Text = trackResponse.MyShipment.MyPackage.Activity[trackResponse.MyShipment.MyPackage.Activity.Length - 1].Timestamp.ToString();
//MessageBox.Show(trackResponse.MyShipment.MyPackage.Activity[trackResponse.MyShipment.MyPackage.Activity.Length - 1].Status.MyStatusType.Code);
txtReference.Text = trackResponse.MyShipment.MyReferenceNumbers[0].Value.ToString();
}
catch (Exception ex)
{
Console.Out.WriteLine(ex.Message);
}
lbReference.Visible = true;
txtReference.Enabled = false;
txtReference.Visible = true;
}
try
{
txtShippedFrom.Text = trackResponse.MyShipment.MyShipper.SourceAddress.AddressLine1 + "\n" +
trackResponse.MyShipment.MyShipper.SourceAddress.City + ", " +
trackResponse.MyShipment.MyShipper.SourceAddress.StateProvinceCode + " " +
trackResponse.MyShipment.MyShipper.SourceAddress.PostalCode;
txtWeight.Text = trackResponse.MyShipment.MyPackage.PackageWeight.Weight.ToString() + " " + trackResponse.MyShipment.MyPackage.PackageWeight.MyUnitOfMeasurement.Code;
txtService.Text = trackResponse.MyShipment.MyService.Description;
}
catch (Exception ex)
{
Console.Out.WriteLine(ex.Message);
}
dgTrackingInfo.DataSource = trackResponse.GetTrackingInfo();
}
