public CarrierController(ICarrierService carrierService, IUserProfileService userProfileService, ISecurityService securityService, IUserContext userContext)
{
_carrierService = carrierService;
_userProfileService = userProfileService;
_securityService = securityService;
_userContext = userContext;
}
public virtual void Test()
{
if (Plugin.Current != null)
{
Save.Press();
ICarrierService plugin = CreateCarrierService(this, Plugin.Current);
if (plugin != null)
{
CarrierResult <string> result = plugin.Test();
if (result.IsSuccess)
{
Plugin.Ask(Plugin.Current, Messages.ConnectionCarrierAskSuccessHeader, Messages.ConnectionCarrierAskSuccess, MessageButtons.OK, MessageIcon.Information);
}
else
{
StringBuilder errorMessages = new StringBuilder();
foreach (Message message in result.Messages)
{
errorMessages.AppendLine(message.Description);
}
if (errorMessages.Length > 0)
{
throw new PXException(PXMessages.LocalizeFormatNoPrefixNLA(Messages.TestFailed, errorMessages.ToString()));
}
}
}
}
}
public static ICarrierService CreateCarrierService(PXGraph graph, CarrierPlugin plugin)
{
ICarrierService service = null;
if (!string.IsNullOrEmpty(plugin.PluginTypeName))
{
try
{
Type carrierType = PXBuildManager.GetType(plugin.PluginTypeName, true);
service = (ICarrierService)Activator.CreateInstance(carrierType);
PXSelectBase <CarrierPluginDetail> select = new PXSelect <CarrierPluginDetail, Where <CarrierPluginDetail.carrierPluginID, Equal <Required <CarrierPluginDetail.carrierPluginID> > > >(graph);
PXResultset <CarrierPluginDetail> resultset = select.Select(plugin.CarrierPluginID);
IList <ICarrierDetail> list = new List <ICarrierDetail>(resultset.Count);
foreach (CarrierPluginDetail item in resultset)
{
list.Add(item);
}
service.LoadSettings(list);
}
catch (Exception ex)
{
throw new PXException(Messages.FailedToCreateCarrierPlugin, ex.Message);
}
}
return(service);
}
public static IList <string> GetCarrierPluginAttributes(PXGraph graph, string carrierPluginID)
{
CarrierPlugin plugin = PXSelect <CarrierPlugin,
Where <CarrierPlugin.carrierPluginID, Equal <Required <CarrierPlugin.carrierPluginID> > > > .Select(graph, carrierPluginID);
if (plugin == null)
{
throw new PXException(Messages.FailedToFindCarrierPlugin, carrierPluginID);
}
ICarrierService service = null;
if (!string.IsNullOrEmpty(plugin.PluginTypeName))
{
try
{
Type carrierType = PXBuildManager.GetType(plugin.PluginTypeName, true);
service = (ICarrierService)Activator.CreateInstance(carrierType);
}
catch (Exception ex)
{
throw new PXException(Messages.FailedToCreateCarrierPlugin, ex.Message);
}
}
return(service == null ? new List <String>() : service.Attributes);
}
public ServiceController(
IServiceService propertyService,
ICarrierService carrierService)
{
_carrierService = carrierService;
_serviceService = propertyService;
}
public FeedbackController(
ICarrierService carrierService,
IFeedbackService feedbackService)
{
_feedbackService = feedbackService;
_carrierService = carrierService;
}
public PropertyController(
IPropertyService propertyService,
ICarrierService carrierService)
{
_carrierService = carrierService;
_propertyService = propertyService;
}
public ServiceController(
IServiceService serviceService,
ICarrierService carrierService)
{
_carrierService = carrierService;
_serviceService = serviceService;
}
public BudgetController(IPolicyService policyService, ICarrierService carrierService,
ICommonService commonService, IClientService clinetService)
{
_policyService = policyService;
_carrierService = carrierService;
_commonService = commonService;
_clinetService = clinetService;
}
public CommisionController(ICarrierService carrierService, ICommisionService commisionService,
ICommonService commonService, IClientService clientService, IPolicyService policyService)
{
_carrierService = carrierService;
_commisionService = commisionService;
_commonService = commonService;
_clientService = clientService;
_policyService = policyService;
}
public CarrierController(
ICarrierService carrierService,
IUserService userService,
IFeedbackService feedbackService)
{
_carrierService = carrierService;
_userService = userService;
_feedbackService = feedbackService;
}
public CarrierController(
ICarrierService carrierService,
IUserService userService,
LogService logService)
{
_carrierService = carrierService;
_userService = userService;
_logService = logService;
}
// private readonly IClientService _clientService;
public PolicyService(IPolicyRepository policyRepository, ICarrierService carrierService,
ICommonService commonService//, IClientService clientService
)
{
_policyRepository = policyRepository;
_carrierService = carrierService;
_commonService = commonService;
// _clientService = clientService;
}
public virtual void ImportSettings()
{
if (Plugin.Current != null)
{
ICarrierService plugin = CreateCarrierService(this, Plugin.Current);
if (plugin != null)
{
IList <ICarrierDetail> details = plugin.ExportSettings();
InsertDetails(details);
}
}
}
public SalesApplication(
IUserService userService,
IProductService productService,
ICarrierService carrierService,
ISaleService saleService)
{
this.userService = userService;
this.productService = productService;
this.carrierService = carrierService;
this.saleService = saleService;
random = new Random();
}
public WindowsUserDialogService(IRouteService routeService, IFlightService flightService,
IAirplaneService airplaneService, IAirportService airportService, IPassengerService passengerService,
ITicketService ticketService, ICarrierService carrierService)
{
_routeService = routeService;
_flightService = flightService;
_airplaneService = airplaneService;
_airportService = airportService;
_passengerService = passengerService;
_ticketService = ticketService;
_carrierService = carrierService;
}
public void SetUp()
{
_carrierService = A.Fake <ICarrierService>();
_carrier = new CarrierDTO
{
Id = 1,
Name = "Быстрая доставка",
Address = "пр-т Дзержинского 104, оф. 18",
Phone = "+375 29 6214177",
Description = "Быстрая доставка мелких товаров по городу.",
};
}
private void PrepareCertificationData(CarrierPlugin cp)
{
ICarrierService plugin = CreateCarrierService(this, cp);
if (plugin != null)
{
UploadFileMaintenance upload = PXGraph.CreateInstance <UploadFileMaintenance>();
CarrierResult <IList <CarrierCertificationData> > result = plugin.GetCertificationData();
if (result != null)
{
StringBuilder sb = new StringBuilder();
foreach (Message message in result.Messages)
{
sb.AppendFormat("{0}:{1} ", message.Code, message.Description);
}
if (result.IsSuccess)
{
CarrierPlugin copy = (CarrierPlugin)Plugin.Cache.CreateCopy(cp);
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
ZipArchive zip = new ZipArchive(ms, false);
foreach (CarrierCertificationData d in result.Result)
{
using (System.IO.Stream zipStream = zip.OpenWrite(string.Format("{0}.{1}", d.Description, d.Format)))
{
zipStream.Write(d.File, 0, d.File.Length);
}
}
FileInfo file = new FileInfo("CertificationData.zip", null, ms.ToArray());
upload.SaveFile(file, FileExistsAction.CreateVersion);
PXNoteAttribute.SetFileNotes(Plugin.Cache, copy, file.UID.Value);
}
Plugin.Update(copy);
this.Save.Press();
}
else
{
throw new PXException(SO.Messages.CarrierServiceError, sb.ToString());
}
}
}
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
customerServices = new CustomerServices();
carrierService = new CarrierService();
areaService = new AreaService();
agentService = new AgentService();
countryService = new CountryService();
unitService = new UnitService();
province = new ProvinceService();
shipmentServices = new ShipmentServicesImpl();
crmService = new CRMService();
ViewData["CountryList"] = new SelectList(Countries, "Id", "CountryName");
sessageStaus = string.Empty;
}
protected virtual void CarrierPlugin_RowSelected(PXCache sender, PXRowSelectedEventArgs e)
{
CarrierPlugin row = e.Row as CarrierPlugin;
if (row == null)
{
return;
}
ICarrierService service = CreateCarrierService(this, row);
if (service != null)
{
certify.SetVisible(service.Attributes.Contains("CERTIFICATE"));
}
}
public static ICarrierService CreateCarrierService(PXGraph graph, string carrierID)
{
if (string.IsNullOrEmpty(carrierID))
{
throw new ArgumentNullException();
}
ICarrierService service = null;
Carrier carrier = PXSelect <Carrier, Where <Carrier.carrierID, Equal <Required <Carrier.carrierID> > > > .Select(graph, carrierID);
if (carrier != null && carrier.IsExternal == true && !string.IsNullOrEmpty(carrier.CarrierPluginID))
{
service = CarrierPluginMaint.CreateCarrierService(graph, carrier.CarrierPluginID);
service.Method = carrier.PluginMethod;
}
return(service);
}
public UserProfileService(LoadshopDataContext context,
IMapper mapper,
ICarrierService carrierService,
ICommonService commonService,
ISecurityService securityService,
IUserContext userContext,
ISMSService smsService,
IAgreementDocumentService agreementDocumentService)
{
_context = context;
_mapper = mapper;
_carrierService = carrierService;
_commonService = commonService;
_securityService = securityService;
_userContext = userContext;
_smsService = smsService;
_agreementDocumentService = agreementDocumentService;
}
public static ICarrierService CreateCarrierService(PXGraph graph, string carrierID)
{
if (string.IsNullOrEmpty(carrierID))
{
throw new ArgumentNullException();
}
ICarrierService service = null;
Carrier carrier = CS.Carrier.PK.Find(graph, carrierID);
if (carrier != null && carrier.IsExternal == true && !string.IsNullOrEmpty(carrier.CarrierPluginID))
{
service = CarrierPluginMaint.CreateCarrierService(graph, carrier.CarrierPluginID);
service.Method = carrier.PluginMethod;
}
return(service);
}
protected virtual IEnumerable GetRecords()
{
PXCache cache = this._Graph.Caches[typeof(Carrier)];
Carrier row = cache.Current as Carrier;
if (row != null && row.IsExternal == true && !string.IsNullOrEmpty(row.CarrierPluginID))
{
ICarrierService cs = CarrierPluginMaint.CreateCarrierService(this._Graph, row.CarrierPluginID);
foreach (CarrierMethod cm in cs.AvailableMethods)
{
CarrierPluginMethod cpm = new CarrierPluginMethod();
cpm.Code = cm.Code;
cpm.Description = cm.Description;
yield return(cpm);
}
}
}
private void CalculateFreightCost(bool supressErrors)
{
Carrier carrier = Carrier.PK.Find(Base, "UPSGROUND");
if (carrier != null && carrier.IsExternal == true)
{
var _doc = new SOOrder();
//_doc = SelectFrom<SOOrder>.Where<SOOrder.orderNbr.IsEqual<P.AsString>.And<SOOrder.orderType.IsEqual<P.AsString>>>.View.Select(Base, "SUS2100212", "SO").RowCast<SOOrder>().FirstOrDefault();
_doc.CuryID = Base.Quote.Current.CuryID;
_doc.ShipVia = "UPSGROUND";
_doc.CuryInfoID = Base.Quote.Current.CuryInfoID;
_doc.DocDate = Base.Quote.Current.DocumentDate;
_doc.IsPackageValid = false;
_doc.IsManualPackage = false;
CarrierPlugin plugin = CarrierPlugin.PK.Find(Base, carrier.CarrierPluginID);
ICarrierService cs = CarrierPluginMaint.CreateCarrierService(Base, plugin);
cs.Method = carrier.PluginMethod;
var graph = PXGraph.CreateInstance <SOOrderEntry>();
_doc = graph.Document.Insert(_doc);
graph.Shipping_Address.Cache.Current = new SOShippingAddress();
CarrierRatesExt(graph).RecalculatePackagesForOrder(graph.Document.Current);
CarrierRequest cr = CarrierRatesExt(graph).BuildRateRequest(_doc);
CarrierResult <RateQuote> result = cs.GetRateQuote(cr);
if (result != null)
{
StringBuilder sb = new StringBuilder();
foreach (Message message in result.Messages)
{
sb.AppendFormat("{0}:{1} ", message.Code, message.Description);
}
if (result.IsSuccess)
{
throw new PXException(result.Result.Amount.ToString());
//decimal baseCost = ConvertAmtToBaseCury(result.Result.Currency, arsetup.Current.DefaultRateTypeID, Document.Current.OrderDate.Value, result.Result.Amount);
//SetFreightCost(baseCost);
}
}
}
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
_freightService = new FreightServicesImpl();
_shipmentService = new ShipmentServicesImpl();
carrierService = new CarrierService();
agentService = new AgentService();
areaService = new AreaService();
servicesType = new ServicesTypeServices();
ViewData["CountryList"] = new SelectList(agentService.GetAllCountry(), "Id", "CountryName");
ViewData["AirlineList"] = carrierService.GetAll(x => x.Type == CarrierType.AirLine.ToString());
ViewData["CarrierList"] = carrierService.GetAll(x => x.Type == CarrierType.ShippingLine.ToString());
ViewData["AgentList"] = agentService.GetAll();
List <String> List1 = new List <String>();
ViewData["AreaListDep"] = new SelectList(List1);
ViewData["AreaListDes"] = new SelectList(List1);
ViewData["ServiceList"] = Services;
User1 = (User)Session[AccountController.USER_SESSION_ID];
}
public CarrierController(ICarrierService carrierService)
{
_carrierService = carrierService;
}
public virtual void UpdateRates()
{
if (Documents.Current != null)
{
CarrierRates.Cache.Clear();
ValidatePackages();
bool autoPackWarning = false;
List <CarrierRequestInfo> requests = new List <CarrierRequestInfo>();
foreach (CarrierPlugin plugin in GetApplicableCarrierPlugins())
{
ICarrierService cs = CarrierPluginMaint.CreateCarrierService(Base, plugin);
if (cs != null)
{
CarrierRequest cRequest = BuildQuoteRequest(Documents.Current, plugin);
if (cRequest.PackagesEx.Count == 0)
{
PXTrace.WriteWarning(Messages.AutoPackagingZeroPackWarning, plugin.CarrierPluginID);
autoPackWarning = true;
continue;
}
requests.Add(new CarrierRequestInfo
{
Plugin = plugin,
Service = cs,
Request = cRequest
});
}
}
Parallel.ForEach(requests, info => info.Result = info.Service.GetRateList(info.Request));
int cx = 0;
StringBuilder errorMessages = new StringBuilder();
foreach (CarrierRequestInfo info in requests)
{
CarrierResult <IList <RateQuote> > result = info.Result;
if (result.IsSuccess)
{
foreach (RateQuote item in result.Result)
{
if (item.IsSuccess && item.Currency != Documents.Current.CuryID)
{
if (string.IsNullOrEmpty(arsetup.Current.DefaultRateTypeID))
{
throw new PXException(Messages.RateTypeNotSpecified);
}
}
PXSelectBase <Carrier> selectCarrier = new PXSelectReadonly <Carrier,
Where <Carrier.carrierPluginID, Equal <Required <Carrier.carrierPluginID> >,
And <Carrier.pluginMethod, Equal <Required <Carrier.pluginMethod> >,
And <Carrier.isExternal, Equal <True> > > > >(Base);
foreach (Carrier shipVia in selectCarrier.Select(info.Plugin.CarrierPluginID, item.Method.Code))
{
var r = new SOCarrierRate
{
LineNbr = cx++,
Method = shipVia.CarrierID,
Description = item.Method.Description,
Amount = ConvertAmt(item.Currency, Documents.Current.CuryID, arsetup.Current.DefaultRateTypeID, Documents.Current.DocumentDate.Value, item.Amount),
DeliveryDate = item.DeliveryDate
};
r.Selected = r.Method == Documents.Current.ShipVia;
if (item.DaysInTransit > 0)
{
r.DaysInTransit = item.DaysInTransit;
}
r = CarrierRates.Insert(r);
if (!item.IsSuccess)
{
CarrierRates.Cache.RaiseExceptionHandling(typeof(SOCarrierRate.method).Name, r, null, new PXSetPropertyException("{0}: {1}", PXErrorLevel.RowError, item.Messages[0].Code, item.Messages[0].Description));
}
}
}
}
else
{
foreach (Message message in result.Messages)
{
errorMessages.AppendFormat(PXMessages.LocalizeNoPrefix(Messages.ReturnedError), info.Plugin.CarrierPluginID, message.ToString());
}
if (!string.IsNullOrEmpty(result.RequestData))
{
PXTrace.WriteInformation(result.RequestData);
}
}
}
if (errorMessages.Length > 0)
{
throw new PXException(Messages.CarrierServiceError, errorMessages.ToString());
}
if (autoPackWarning)
{
throw new PXException(Messages.AutoPackagingIssuesCheckTrace);
}
}
}
public CarriersController(ICarrierService carrierService)
{
this.carrierService = carrierService;
}
public CarrierRateController(IService <CarrierRateViewModel> service) : base(service)
{
CarrierService = DependencyResolver.Current.GetService <ICarrierService>();
}
