public ShipmentPackage CreateShipmentPackage(ShipmentPackageInsert shipmentpackage)
{
using (SqlConnection connection = new SqlConnection(DefaultConnection))
{
DynamicParameters p = new DynamicParameters();
p.Add("shipmentid", shipmentpackage.ShipmentID);
p.Add("businessid", shipmentpackage.BusinessID);
p.Add("status", shipmentpackage.Status);
p.Add("packagenumber", shipmentpackage.PackageNumber);
p.Add("dimension", shipmentpackage.Dimension);
p.Add("weight", shipmentpackage.Weight);
p.Add("weightunit", shipmentpackage.WeightUnit);
p.Add("shipmentpackagerateid", shipmentpackage.ShipmentPackageRateID);
p.Add("shippingcarrierid", shipmentpackage.ShippingCarrierID);
p.Add("shippingserviceid", shipmentpackage.ShippingServiceID);
p.Add("shippingpackageid", shipmentpackage.ShippingPackageID);
p.Add("shippingrate", shipmentpackage.ShippingRate);
p.Add("trackingnumber", shipmentpackage.TrackingNumber);
p.Add("uspspicnumber", shipmentpackage.USPSPICNumber);
p.Add("shippinglablepath", shipmentpackage.ShippingLabelPath);
p.Add("shipdate", shipmentpackage.ShipDate);
p.Add("israted", shipmentpackage.IsRated);
p.Add("islabeled", shipmentpackage.IsLabeled);
p.Add("ismanual", shipmentpackage.IsManual);
ShipmentPackage result = connection.Query <ShipmentPackage>("spCreateShipmentPackage", p, commandType: CommandType.StoredProcedure).Single();
return(result);
}
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="ShipmentPackage">Shipment package</param>
/// <param name="Error">Error</param>
/// <returns>Shipping options</returns>
public ShippingOptionCollection GetShippingOptions(ShipmentPackage ShipmentPackage, ref string Error)
{
ShippingOptionCollection shippingOptions = new ShippingOptionCollection();
if (ShipmentPackage == null)
{
throw new ArgumentNullException("ShipmentPackage");
}
if (ShipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
ShippingMethodCollection shippingMethods = ShippingMethodManager.GetAllShippingMethods();
foreach (ShippingMethod shippingMethod in shippingMethods)
{
ShippingOption shippingOption = new ShippingOption();
shippingOption.Name = shippingMethod.Name;
shippingOption.Description = shippingMethod.Description;
shippingOption.Rate = decimal.Zero;
shippingOptions.Add(shippingOption);
}
return(shippingOptions);
}
public virtual ShipmentPackageEntity FromModel(ShipmentPackage package, PrimaryKeyResolvingMap pkMap)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
Id = package.Id;
CreatedDate = package.CreatedDate;
CreatedBy = package.CreatedBy;
ModifiedDate = package.ModifiedDate;
ModifiedBy = package.ModifiedBy;
PackageType = package.PackageType;
Weight = package.Weight;
Height = package.Height;
Width = package.Width;
MeasureUnit = package.MeasureUnit;
WeightUnit = package.WeightUnit;
Length = package.Length;
pkMap.AddPair(package, this);
if (!Items.IsNullOrEmpty())
{
Items = new ObservableCollection <ShipmentItemEntity>(package.Items.Select(x => AbstractTypeFactory <ShipmentItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
foreach (var shipmentItem in Items)
{
shipmentItem.ShipmentPackageId = Id;
}
}
return(this);
}
private ShipmentPackage[] GetPackagesFromGroupedData(KeyValuePair <string, IGrouping <string, ShipmentFileExportRow> > shipmentData, string acumaticaDefaultBoxId)
{
var packages = new List <ShipmentPackage>();
foreach (var shipmentDataPackage in shipmentData.Value)
{
var shipmentPackage = new ShipmentPackage
{
BoxID = new StringValue {
Value = acumaticaDefaultBoxId
},
RowNumber = new LongValue {
Value = shipmentDataPackage.RowNumber > 0 ? shipmentDataPackage.RowNumber : packages.Count + 1
},
Confirmed = new BooleanReturn {
Value = !shipmentDataPackage.VoidIndicator
},
TrackingNumber = new StringValue {
Value = !shipmentDataPackage.VoidIndicator ? shipmentDataPackage.PackageTrackingNumber : string.Empty
},
Weight = new DecimalValue {
Value = shipmentDataPackage.PackageWeight
}
};
packages.Add(shipmentPackage);
}
return(packages.ToArray());
}
public virtual ShipmentPackage ToModel(ShipmentPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
package.Id = Id;
package.CreatedDate = CreatedDate;
package.CreatedBy = CreatedBy;
package.ModifiedDate = ModifiedDate;
package.ModifiedBy = ModifiedBy;
package.PackageType = PackageType;
package.Weight = Weight;
package.Height = Height;
package.Width = Width;
package.MeasureUnit = MeasureUnit;
package.WeightUnit = WeightUnit;
package.Length = Length;
package.Items = Items.Select(x => x.ToModel(AbstractTypeFactory <ShipmentItem> .TryCreateInstance())).ToList();
return(package);
}
private void SetPayment(RateRequest request, ShipmentPackage ShipmentPackage)
{
request.RequestedShipment.ShippingChargesPayment = new Payment(); // Payment Information
request.RequestedShipment.ShippingChargesPayment.PaymentType = PaymentType.SENDER; // Payment options are RECIPIENT, SENDER, THIRD_PARTY
request.RequestedShipment.ShippingChargesPayment.PaymentTypeSpecified = true;
request.RequestedShipment.ShippingChargesPayment.Payor = new Payor();
request.RequestedShipment.ShippingChargesPayment.Payor.AccountNumber = SettingManager.GetSettingValue("ShippingRateComputationMethod.FedEx.AccountNumber"); // Replace "XXX" with client's account number
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <param name="error">Error</param>
/// <returns>Shipping options</returns>
public ShippingOptionCollection GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
{
var shippingOptions = new ShippingOptionCollection();
if (shipmentPackage == null)
{
throw new ArgumentNullException("shipmentPackage");
}
if (shipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
if (shipmentPackage.ShippingAddress == null)
{
error = "Shipping address is not set";
return(shippingOptions);
}
if (shipmentPackage.ShippingAddress.Country == null)
{
error = "Shipping country is not set";
return(shippingOptions);
}
string url = SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.URL");
string accessKey = SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.AccessKey");
string username = SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.Username");
string password = SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.Password");
var customerClassification = (UPSCustomerClassification)Enum.Parse(typeof(UPSCustomerClassification), SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.CustomerClassification"));
var pickupType = (UPSPickupType)Enum.Parse(typeof(UPSPickupType), SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.PickupType"));
var packagingType = (UPSPackagingType)Enum.Parse(typeof(UPSPackagingType), SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.PackagingType"));
decimal additionalHandlingCharge = SettingManager.GetSettingValueDecimalNative("ShippingRateComputationMethod.UPS.AdditionalHandlingCharge");
if (shipmentPackage.CountryFrom == null)
{
int defaultShippedFromCountryID = SettingManager.GetSettingValueInteger("ShippingRateComputationMethod.UPS.DefaultShippedFromCountryID");
shipmentPackage.CountryFrom = CountryManager.GetCountryById(defaultShippedFromCountryID);
}
if (String.IsNullOrEmpty(shipmentPackage.ZipPostalCodeFrom))
{
shipmentPackage.ZipPostalCodeFrom = SettingManager.GetSettingValue("ShippingRateComputationMethod.UPS.DefaultShippedFromZipPostalCode");
}
string requestString = CreateRequest(accessKey, username, password, shipmentPackage,
customerClassification, pickupType, packagingType);
string responseXML = DoRequest(url, requestString);
shippingOptions = ParseResponse(responseXML, ref error);
foreach (var shippingOption in shippingOptions)
{
if (!shippingOption.Name.ToLower().StartsWith("ups"))
{
shippingOption.Name = string.Format("UPS {0}", shippingOption.Name);
}
shippingOption.Rate += additionalHandlingCharge;
}
return(shippingOptions);
}
public virtual ShipmentPackage ToModel(ShipmentPackage package)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
package.InjectFrom(this);
package.Items = this.Items.Select(x => x.ToModel(AbstractTypeFactory <ShipmentItem> .TryCreateInstance())).ToList();
return(package);
}
private List <Item> CreateItems(ShipmentPackage ShipmentPackage)
{
var result = new List <Item>();
var usedMeasureWeight = IoC.Resolve <IMeasureService>().GetMeasureWeightBySystemKeyword("kg");
if (usedMeasureWeight == null)
{
throw new NopException("CanadaPost shipping service. Could not load \"kg\" measure weight");
}
var usedMeasureDimension = IoC.Resolve <IMeasureService>().GetMeasureDimensionBySystemKeyword("meters");
if (usedMeasureDimension == null)
{
throw new NopException("CanadaPost shipping service. Could not load \"meter(s)\" measure dimension");
}
foreach (var sci in ShipmentPackage.Items)
{
var pv = sci.ProductVariant;
var item = new Item();
item.Quantity = sci.Quantity;
//Canada Post uses kg(s)
decimal unitWeight = sci.TotalWeight / sci.Quantity;
item.Weight = IoC.Resolve <IMeasureService>().ConvertWeight(unitWeight, IoC.Resolve <IMeasureService>().BaseWeightIn, usedMeasureWeight);
item.Weight = Math.Round(item.Weight, 2);
if (item.Weight == decimal.Zero)
{
item.Weight = 0.01M;
}
//Canada Post uses centimeters
item.Length = Convert.ToInt32(Math.Ceiling(IoC.Resolve <IMeasureService>().ConvertDimension(pv.Length, IoC.Resolve <IMeasureService>().BaseDimensionIn, usedMeasureDimension) * 100));
if (item.Length == decimal.Zero)
{
item.Length = 1;
}
item.Width = Convert.ToInt32(Math.Ceiling(IoC.Resolve <IMeasureService>().ConvertDimension(pv.Width, IoC.Resolve <IMeasureService>().BaseDimensionIn, usedMeasureDimension) * 100));
if (item.Width == decimal.Zero)
{
item.Width = 1;
}
item.Height = Convert.ToInt32(Math.Ceiling(IoC.Resolve <IMeasureService>().ConvertDimension(pv.Height, IoC.Resolve <IMeasureService>().BaseDimensionIn, usedMeasureDimension) * 100));
if (item.Height == decimal.Zero)
{
item.Height = 1;
}
result.Add(item);
}
return(result);
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <param name="error">Error</param>
/// <returns>Shipping options</returns>
public List <ShippingOption> GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
{
var shippingOptions = new List <ShippingOption>();
if (shipmentPackage == null)
{
throw new ArgumentNullException("shipmentPackage");
}
if (shipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
if (shipmentPackage.ShippingAddress == null)
{
error = "Shipping address is not set";
return(shippingOptions);
}
if (shipmentPackage.ShippingAddress.Country == null)
{
error = "Shipping country is not set";
return(shippingOptions);
}
decimal subTotal = decimal.Zero;
foreach (var shoppingCartItem in shipmentPackage.Items)
{
if (shoppingCartItem.IsFreeShipping)
{
continue;
}
subTotal += PriceHelper.GetSubTotal(shoppingCartItem, shipmentPackage.Customer, true);
}
decimal weight = IoC.Resolve <IShippingService>().GetShoppingCartTotalWeight(shipmentPackage.Items, shipmentPackage.Customer);
var shippingMethods = IoC.Resolve <IShippingService>().GetAllShippingMethods(shipmentPackage.ShippingAddress.CountryId);
foreach (var shippingMethod in shippingMethods)
{
decimal?rate = GetRate(subTotal, weight, shippingMethod.ShippingMethodId);
if (rate.HasValue)
{
var shippingOption = new ShippingOption();
shippingOption.Name = shippingMethod.Name;
shippingOption.Description = shippingMethod.Description;
shippingOption.Rate = rate.Value;
shippingOptions.Add(shippingOption);
}
}
return(shippingOptions);
}
bool IsDomestic(ShipmentPackage shipmentPackage)
{
bool result = true;
if (shipmentPackage != null &&
shipmentPackage.ShippingAddress != null &&
shipmentPackage.ShippingAddress.Country != null && shipmentPackage.CountryFrom != null)
{
result = shipmentPackage.ShippingAddress.Country.ThreeLetterIsoCode == "USA" && shipmentPackage.CountryFrom.ThreeLetterIsoCode == "USA";
}
return(result);
}
public static ShipmentPackage ToWebModel(this VirtoCommerceOrderModuleWebModelShipmentPackage shipmentPackage, IEnumerable <Currency> currencies, Language language)
{
var webModel = new ShipmentPackage();
webModel.InjectFrom(shipmentPackage);
if (shipmentPackage.Items != null)
{
webModel.Items = shipmentPackage.Items.Select(i => i.ToWebModel(currencies, language)).ToList();
}
return(webModel);
}
public static ShipmentPackage ToWebModel(this VirtoCommerceOrderModuleWebModelShipmentPackage shipmentPackage)
{
var webModel = new ShipmentPackage();
webModel.InjectFrom(shipmentPackage);
if (shipmentPackage.Items != null)
{
webModel.Items = shipmentPackage.Items.Select(i => i.ToWebModel()).ToList();
}
return(webModel);
}
/// <summary>
/// Is a request domestic
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <returns>Rsult</returns>
protected bool IsDomesticRequest(ShipmentPackage shipmentPackage)
{
//Origin Country must be USA, Collect USA from list of countries
bool result = true;
if (shipmentPackage != null &&
shipmentPackage.ShippingAddress != null &&
shipmentPackage.ShippingAddress.Country != null)
{
result = shipmentPackage.ShippingAddress.Country.ThreeLetterIsoCode == "USA";
}
return(result);
}
public virtual ShipmentPackage ToShipmentPackage(orderDto.ShipmentPackage shipmentPackageDto, IEnumerable <Currency> currencies, Language language)
{
var webModel = new ShipmentPackage();
webModel.InjectFrom <NullableAndEnumValueInjecter>(shipmentPackageDto);
if (shipmentPackageDto.Items != null)
{
webModel.Items = shipmentPackageDto.Items.Select(i => ToShipmentItem(i, currencies, language)).ToList();
}
return(webModel);
}
private void SetShipmentDetails(RateRequest request, ShipmentPackage ShipmentPackage, decimal orderSubTotal)
{
request.RequestedShipment = new RequestedShipment();
request.RequestedShipment.DropoffType = DropoffType.REGULAR_PICKUP; //Drop off types are BUSINESS_SERVICE_CENTER, DROP_BOX, REGULAR_PICKUP, REQUEST_COURIER, STATION
request.RequestedShipment.TotalInsuredValue = new Money();
request.RequestedShipment.TotalInsuredValue.Amount = orderSubTotal;
request.RequestedShipment.TotalInsuredValue.Currency = CurrencyManager.PrimaryStoreCurrency.CurrencyCode.ToString();
request.RequestedShipment.ShipTimestamp = DateTime.Now; // Shipping date and time
request.RequestedShipment.ShipTimestampSpecified = true;
request.RequestedShipment.RateRequestTypes = new RateRequestType[2];
request.RequestedShipment.RateRequestTypes[0] = RateRequestType.ACCOUNT;
request.RequestedShipment.RateRequestTypes[1] = RateRequestType.LIST;
request.RequestedShipment.PackageDetail = RequestedPackageDetailType.INDIVIDUAL_PACKAGES;
request.RequestedShipment.PackageDetailSpecified = true;
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="ShipmentPackage">Shipment package</param>
/// <param name="Error">Error</param>
/// <returns>Shipping options</returns>
public ShippingOptionCollection GetShippingOptions(ShipmentPackage ShipmentPackage, ref string Error)
{
ShippingOptionCollection shippingOptions = new ShippingOptionCollection();
if (ShipmentPackage == null)
{
throw new ArgumentNullException("ShipmentPackage");
}
if (ShipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
if (ShipmentPackage.ShippingAddress == null)
{
Error = "Shipping address is not set";
return(shippingOptions);
}
if (ShipmentPackage.ShippingAddress.Country == null)
{
Error = "Shipping country is not set";
return(shippingOptions);
}
decimal subTotal = decimal.Zero;
foreach (ShoppingCartItem shoppingCartItem in ShipmentPackage.Items)
{
if (shoppingCartItem.IsFreeShipping)
{
continue;
}
subTotal += PriceHelper.GetSubTotal(shoppingCartItem, ShipmentPackage.Customer, true);
}
decimal weight = ShippingManager.GetShoppingCartTotalWeigth(ShipmentPackage.Items);
ShippingMethodCollection shippingMethods = ShippingMethodManager.GetAllShippingMethods();
foreach (ShippingMethod shippingMethod in shippingMethods)
{
ShippingOption shippingOption = new ShippingOption();
shippingOption.Name = shippingMethod.Name;
shippingOption.Description = shippingMethod.Description;
shippingOption.Rate = GetRate(subTotal, weight, shippingMethod.ShippingMethodID, ShipmentPackage.ShippingAddress.Country.CountryID);
shippingOptions.Add(shippingOption);
}
return(shippingOptions);
}
public virtual ShipmentPackageEntity FromModel(ShipmentPackage package, PrimaryKeyResolvingMap pkMap)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
pkMap.AddPair(package, this);
this.InjectFrom(package);
if (!this.Items.IsNullOrEmpty())
{
this.Items = new ObservableCollection <ShipmentItemEntity>(package.Items.Select(x => AbstractTypeFactory <ShipmentItemEntity> .TryCreateInstance().FromModel(x, pkMap)));
}
return(this);
}
public static ShipmentPackage ToCoreModel(this ShipmentPackageEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
var retVal = new ShipmentPackage();
retVal.InjectFrom(entity);
if (entity.Items != null)
{
retVal.Items = entity.Items.Select(x => x.ToCoreModel()).ToList();
}
return(retVal);
}
public static ShipmentPackageEntity ToDataModel(this ShipmentPackage package, CustomerOrderEntity orderEntity)
{
if (package == null)
{
throw new ArgumentNullException("package");
}
var retVal = new ShipmentPackageEntity();
retVal.InjectFrom(package);
if (package.Items != null)
{
retVal.Items = new ObservableCollection <ShipmentItemEntity>(package.Items.Select(x => x.ToDataModel(orderEntity)));
}
return(retVal);
}
private RateRequest CreateRateRequest(ShipmentPackage ShipmentPackage)
{
// Build the RateRequest
var request = new RateRequest();
request.WebAuthenticationDetail = new WebAuthenticationDetail();
request.WebAuthenticationDetail.UserCredential = new WebAuthenticationCredential();
request.WebAuthenticationDetail.UserCredential.Key = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.FedEx.Key"); // Replace "XXX" with the Key
request.WebAuthenticationDetail.UserCredential.Password = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.FedEx.Password"); // Replace "XXX" with the Password
request.ClientDetail = new ClientDetail();
request.ClientDetail.AccountNumber = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.FedEx.AccountNumber"); // Replace "XXX" with client's account number
request.ClientDetail.MeterNumber = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.FedEx.MeterNumber"); // Replace "XXX" with client's meter number
request.TransactionDetail = new TransactionDetail();
request.TransactionDetail.CustomerTransactionId = "***Rate Available Services v7 Request - nopCommerce***"; // This is a reference field for the customer. Any value can be used and will be provided in the response.
request.Version = new VersionId(); // WSDL version information, value is automatically set from wsdl
request.ReturnTransitAndCommit = true;
request.ReturnTransitAndCommitSpecified = true;
request.CarrierCodes = new CarrierCodeType[2];
// Insert the Carriers you would like to see the rates for
request.CarrierCodes[0] = CarrierCodeType.FDXE;
request.CarrierCodes[1] = CarrierCodeType.FDXG;
decimal subtotalBase = decimal.Zero;
decimal orderSubTotalDiscountAmount = decimal.Zero;
Discount orderSubTotalAppliedDiscount = null;
decimal subTotalWithoutDiscountBase = decimal.Zero;
decimal subTotalWithDiscountBase = decimal.Zero;
IoC.Resolve <IShoppingCartService>().GetShoppingCartSubTotal(ShipmentPackage.Items,
ShipmentPackage.Customer, out orderSubTotalDiscountAmount, out orderSubTotalAppliedDiscount,
out subTotalWithoutDiscountBase, out subTotalWithDiscountBase);
subtotalBase = subTotalWithDiscountBase;
SetShipmentDetails(request, ShipmentPackage, subtotalBase);
SetOrigin(request);
SetDestination(request, ShipmentPackage);
SetPayment(request, ShipmentPackage);
SetIndividualPackageLineItems(request, ShipmentPackage, subtotalBase);
return(request);
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <param name="error">Error</param>
/// <returns>Shipping options</returns>
public ShippingOptionCollection GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
{
var shippingOptions = new ShippingOptionCollection();
if (shipmentPackage == null)
{
throw new ArgumentNullException("shipmentPackage");
}
if (shipmentPackage.Items == null)
{
throw new NopException("Нет товаров для доставки. ");
}
if (shipmentPackage.ShippingAddress == null)
{
error = "Не указан адрес доставки. ";
return(shippingOptions);
}
if (shipmentPackage.ShippingAddress.Country == null)
{
error = "Не указана страна доставки. ";
return(shippingOptions);
}
var shippingMethods = ShippingMethodManager.GetAllShippingMethods(shipmentPackage.ShippingAddress.CountryId);
foreach (var shippingMethod in shippingMethods)
{
var shippingOption = new ShippingOption();
shippingOption.Name = shippingMethod.Name;
shippingOption.Description = shippingMethod.Description;
if (shippingMethod.ShippingMethodId == 4)
{
shippingOption.Rate = 0;
}
else
{
shippingOption.Rate = GetRate();
}
shippingOptions.Add(shippingOption);
}
return(shippingOptions);
}
private void SetDestination(RateRequest request, ShipmentPackage ShipmentPackage)
{
request.RequestedShipment.Recipient = new Party();
request.RequestedShipment.Recipient.Address = new Address();
request.RequestedShipment.Recipient.Address.StreetLines = new string[1] {
"Recipient Address Line 1"
};
request.RequestedShipment.Recipient.Address.City = ShipmentPackage.ShippingAddress.City;
if (ShipmentPackage.ShippingAddress.StateProvince != null)
{
request.RequestedShipment.Recipient.Address.StateOrProvinceCode = ShipmentPackage.ShippingAddress.StateProvince.Abbreviation;
}
else
{
request.RequestedShipment.Recipient.Address.StateOrProvinceCode = string.Empty;
}
request.RequestedShipment.Recipient.Address.PostalCode = ShipmentPackage.ShippingAddress.ZipPostalCode;
request.RequestedShipment.Recipient.Address.CountryCode = ShipmentPackage.ShippingAddress.Country.TwoLetterISOCode;
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <param name="error">Error</param>
/// <returns>Shipping options</returns>
public List <ShippingOption> GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
{
var shippingOptions = new List <ShippingOption>();
if (shipmentPackage == null)
{
throw new ArgumentNullException("shipmentPackage");
}
if (shipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
if (shipmentPackage.ShippingAddress == null)
{
error = "Shipping address is not set";
return(shippingOptions);
}
string url = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.URL");
string username = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.Username");
string password = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.Password");
decimal additionalHandlingCharge = IoC.Resolve <ISettingManager>().GetSettingValueDecimalNative("ShippingRateComputationMethod.USPS.AdditionalHandlingCharge");
shipmentPackage.ZipPostalCodeFrom = IoC.Resolve <ISettingManager>().GetSettingValue("ShippingRateComputationMethod.USPS.DefaultShippedFromZipPostalCode");
bool isDomestic = IsDomesticRequest(shipmentPackage);
string requestString = CreateRequest(username, password, shipmentPackage);
string responseXML = DoRequest(url, requestString);
shippingOptions = ParseResponse(responseXML, isDomestic, ref error);
foreach (var shippingOption in shippingOptions)
{
if (!shippingOption.Name.ToLower().StartsWith("usps"))
{
shippingOption.Name = string.Format("USPS {0}", shippingOption.Name);
}
shippingOption.Rate += additionalHandlingCharge;
}
return(shippingOptions);
}
public virtual ShipmentPackage ToShipmentPackage(orderDto.ShipmentPackage shipmentPackageDto, IEnumerable <Currency> currencies, Language language)
{
var result = new ShipmentPackage();
result.BarCode = shipmentPackageDto.BarCode;
result.Id = shipmentPackageDto.Id;
result.Height = shipmentPackageDto.Height;
result.Weight = shipmentPackageDto.Weight;
result.Length = shipmentPackageDto.Length;
result.Width = shipmentPackageDto.Width;
result.WeightUnit = shipmentPackageDto.WeightUnit;
result.MeasureUnit = shipmentPackageDto.MeasureUnit;
if (shipmentPackageDto.Items != null)
{
result.Items = shipmentPackageDto.Items.Select(i => ToShipmentItem(i, currencies, language)).ToList();
}
return(result);
}
/// <summary>
/// Gets fixed shipping rate (if shipping rate computation method allows it and the rate can be calculated before checkout).
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <returns>Fixed shipping rate; or null if shipping rate could not be calculated before checkout</returns>
public decimal?GetFixedRate(ShipmentPackage shipmentPackage)
{
if (shipmentPackage == null)
{
return(null);
}
if (shipmentPackage.Items == null)
{
return(null);
}
if (shipmentPackage.ShippingAddress == null)
{
return(null);
}
if (shipmentPackage.ShippingAddress.Country == null)
{
return(null);
}
var shippingMethods = IoC.Resolve <IShippingService>().GetAllShippingMethods(shipmentPackage.ShippingAddress.CountryId);
List <decimal> rates = new List <decimal>();
foreach (var shippingMethod in shippingMethods)
{
decimal rate = GetRate(shippingMethod.ShippingMethodId);
if (!rates.Contains(rate))
{
rates.Add(rate);
}
}
//return default rate if all of them equal
if (rates.Count == 1)
{
return(rates[0]);
}
return(null);
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="ShipmentPackage">Shipment option</param>
/// <param name="Error">Error</param>
/// <returns>Shipping options</returns>
public ShippingOptionCollection GetShippingOptions(ShipmentPackage ShipmentPackage, ref string Error)
{
ShippingOptionCollection shippingOptions = new ShippingOptionCollection();
if (ShipmentPackage == null)
{
throw new ArgumentNullException("ShipmentPackage");
}
if (ShipmentPackage.Items == null)
{
throw new NopSolutions.NopCommerce.Common.NopException("No shipment items");
}
if (ShipmentPackage.ShippingAddress == null)
{
Error = "Shipping address is not set";
return(shippingOptions);
}
string url = SettingManager.GetSettingValue("ShippingRateComputationMethod.USPS.URL");
string username = SettingManager.GetSettingValue("ShippingRateComputationMethod.USPS.Username");
string password = SettingManager.GetSettingValue("ShippingRateComputationMethod.USPS.Password");
decimal additionalHandlingCharge = SettingManager.GetSettingValueDecimalNative("ShippingRateComputationMethod.USPS.AdditionalHandlingCharge");
ShipmentPackage.ZipPostalCodeFrom = SettingManager.GetSettingValue("ShippingRateComputationMethod.USPS.DefaultShippedFromZipPostalCode");
string requestString = CreateRequest(username, password, ShipmentPackage);
string responseXML = DoRequest(url, requestString);
shippingOptions = ParseResponse(responseXML, ref Error);
foreach (ShippingOption shippingOption in shippingOptions)
{
shippingOption.Rate += additionalHandlingCharge;
}
if (String.IsNullOrEmpty(Error) && shippingOptions.Count == 0)
{
Error = "Shipping options could not be loaded";
}
return(shippingOptions);
}
public static ShipmentPackage ToShipmentPackage(this orderDto.ShipmentPackage shipmentPackageDto, IEnumerable <Currency> currencies, Language language)
{
var result = new ShipmentPackage
{
BarCode = shipmentPackageDto.BarCode,
Id = shipmentPackageDto.Id,
Height = shipmentPackageDto.Height,
Weight = shipmentPackageDto.Weight,
Length = shipmentPackageDto.Length,
Width = shipmentPackageDto.Width,
WeightUnit = shipmentPackageDto.WeightUnit,
MeasureUnit = shipmentPackageDto.MeasureUnit
};
if (shipmentPackageDto.Items != null)
{
result.Items = shipmentPackageDto.Items.Select(i => ToShipmentItem(i, currencies, language)).ToList();
}
return(result);
}
private void SetDestination(RateRequest request, ShipmentPackage ShipmentPackage)
{
request.RequestedShipment.Recipient = new Party();
request.RequestedShipment.Recipient.Address = new Address();
if (SettingManager.GetSettingValueBoolean("ShippingRateComputationMethod.FedEx.UseResidentialRates", false))
{
request.RequestedShipment.Recipient.Address.Residential = true;
request.RequestedShipment.Recipient.Address.ResidentialSpecified = true;
}
request.RequestedShipment.Recipient.Address.StreetLines = new string[1] {
"Recipient Address Line 1"
};
request.RequestedShipment.Recipient.Address.City = ShipmentPackage.ShippingAddress.City;
if (ShipmentPackage.ShippingAddress.StateProvince != null)
{
request.RequestedShipment.Recipient.Address.StateOrProvinceCode = ShipmentPackage.ShippingAddress.StateProvince.Abbreviation;
}
else
{
request.RequestedShipment.Recipient.Address.StateOrProvinceCode = string.Empty;
}
request.RequestedShipment.Recipient.Address.PostalCode = ShipmentPackage.ShippingAddress.ZipPostalCode;
request.RequestedShipment.Recipient.Address.CountryCode = ShipmentPackage.ShippingAddress.Country.TwoLetterIsoCode;
}
/// <summary>
/// Gets available shipping options
/// </summary>
/// <param name="shipmentPackage">Shipment package</param>
/// <param name="error">Error</param>
/// <returns>Shipping options</returns>
public List <ShippingOption> GetShippingOptions(ShipmentPackage shipmentPackage, ref string error)
{
var shippingOptions = new List <ShippingOption>();
if (shipmentPackage == null)
{
throw new ArgumentNullException("shipmentPackage");
}
if (shipmentPackage.Items == null)
{
throw new NopException("No shipment items");
}
if (shipmentPackage.ShippingAddress == null)
{
error = "Shipping address is not set";
return(shippingOptions);
}
if (shipmentPackage.ShippingAddress.Country == null)
{
error = "Shipping country is not set";
return(shippingOptions);
}
var shippingMethods = ShippingMethodManager.GetAllShippingMethods(shipmentPackage.ShippingAddress.CountryId);
foreach (var shippingMethod in shippingMethods)
{
var shippingOption = new ShippingOption();
shippingOption.Name = shippingMethod.Name;
shippingOption.Description = shippingMethod.Description;
shippingOption.Rate = GetRate();
shippingOptions.Add(shippingOption);
}
return(shippingOptions);
}
