Out bound
/// <summary>
/// API helper
/// </summary>
public static class GopAPIHelper
{
/// <summary>
/// send to API
/// </summary>
/// <param name = "_url">URL</param>
/// <param name = "_clientId">Client id</param>
/// <param name = "_clientSecret">client secret</param>
/// <param name = "_json">Notes</param>
/// <param name = "_method">method</param>
/// <returns>RetailWebResponse</returns>
public static RetailWebResponse sendToAPI(URL _url, String255 _clientId, String255 _clientSecret, Notes _json, str _method)
{
#define.clientId("client_id")
#define.clientSecret("client_secret")
System.Net.HttpWebRequest request = null;
System.Net.HttpWebResponse response = null;
CLRObject webResponse;
System.Net.WebHeaderCollection headers;
System.IO.MemoryStream stream;
Binary requestContent;
str responseData;
System.Exception ex;
System.Net.WebException webException;
RetailWebResponse retailWebResponse;
int httpStatusCode;
str contentType;
try
{
ttsbegin;
request = System.Net.WebRequest::Create(_url) as System.Net.HttpWebRequest;
request.set_Method(_method);
request.AllowAutoRedirect = false;
headers = request.get_Headers();
headers.Add(#clientId, _clientId);
headers.Add(#clientSecret, _clientSecret);
request.set_Headers(headers);
request.set_ContentType(@"application/json");
System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();
System.Byte[] bytes = encoding.GetBytes(_json);
if (bytes)
{
GopAPIHelper::writeRequestData(request, bytes);
}
webResponse = request.GetResponse();
response = webResponse as System.Net.HttpWebResponse;
ttscommit;
}
catch (ex)
{
ex = ClrInterop::getLastException();
if (ex != null)
{
ex = ex.get_InnerException();
if ((ex != null) && (ex is System.Net.WebException))
{
webException = ex as System.Net.WebException;
webResponse = webException.get_Response();
response = webResponse as System.Net.HttpWebResponse;
}
}
}
responseData = GopAPIHelper::readResponseData(response);
response.Close();
httpStatusCode = response.get_StatusCode();
if (httpStatusCode >= 300 && httpStatusCode <= 399)
{
retailWebResponse = GopAPIHelper::sendToAPI(response.GetResponseHeader("Location"), _clientId, _clientSecret, _json, _method);
return retailWebResponse;
}
contentType = response.get_ContentType();
retailWebResponse = new RetailWebResponse(httpStatusCode, responseData, contentType);
return retailWebResponse;
}
/// <summary>
/// read response data
/// </summary>
/// <param name = "response">response</param>
/// <returns>string</returns>
private static str readResponseData(System.Net.HttpWebResponse response)
{
int batchSize = 1024;
System.IO.Stream receiveStream;
System.IO.StreamReader readStream;
System.Text.Encoding encode;
System.Char[] read;
System.Text.StringBuilder sb;
System.String readString;
str contentEncoding;
int countRead;
if (response == null)
{
return "";
}
receiveStream = response.GetResponseStream();
contentEncoding = response.get_ContentEncoding();
if (contentEncoding)
{
encode = System.Text.Encoding::GetEncoding(contentEncoding);
}
else
{
encode = new System.Text.UTF8Encoding();
}
readStream = new System.IO.StreamReader(receiveStream, encode);
read = new System.Char[batchSize]();
countRead = readStream.Read(read, 0, batchSize);
sb = new System.Text.StringBuilder();
while (countRead > 0)
{
readString = new System.String(read, 0, countRead);
sb.Append(readString);
countRead = readStream.Read(read, 0, batchSize);
}
readStream.Close();
return sb.ToString();
}
/// <summary>
/// Request
/// </summary>
/// <param name = "_request">request</param>
/// <param name = "_bytes">Bytes</param>
private static void writeRequestData(System.Net.HttpWebRequest _request, System.Byte[] _bytes)
{
System.IO.Stream stream;
_request.set_ContentLength(_bytes.get_Length());
stream = _request.GetRequestStream();
stream.Write(_bytes, 0, _bytes.get_Length());
stream.Close();
}
}
------------------------------------------------------------------------------
/// <summary>
/// Root Response contract
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopResponseRootContract
{
private GopResponseHeaderContract responseHeader;
private GopResponseContract response;
/// <summary>
/// responseHeader
/// </summary>
/// <param name = "_value">responseHeader</param>
/// <returns>responseHeader</returns>
[DataMember("responseHeader")]
public GopResponseHeaderContract parmResponseHeader(GopResponseHeaderContract _value = responseHeader)
{
responseHeader = _value;
return responseHeader;
}
/// <summary>
/// response
/// </summary>
/// <param name = "_value">response</param>
/// <returns>response</returns>
[DataMember("response")]
public GopResponseContract parmResponse(GopResponseContract _value = response)
{
response = _value;
return response;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Response header
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopResponseHeaderContract
{
private str channelName;
private str senderId;
private str receiverId;
private str countryCode;
private str messageId;
private str dateTime;
private str status;
/// <summary>
/// senderId
/// </summary>
/// <param name = "_value">senderId</param>
/// <returns>senderId</returns>
[DataMember("senderId")]
public str parmSenderId(str _value = senderId)
{
if (!prmIsDefault(_value))
{
senderId = _value;
}
return senderId;
}
/// <summary>
/// channelName
/// </summary>
/// <param name = "_value">channelName</param>
/// <returns>channelName</returns>
[DataMember("channelName")]
public str parmChannelName(str _value = channelName)
{
if (!prmIsDefault(_value))
{
channelName = _value;
}
return channelName;
}
/// <summary>
/// receiverId
/// </summary>
/// <param name = "_value">receiverId</param>
/// <returns>receiverId</returns>
[DataMember("receiverId")]
public str parmReceiverId(str _value = receiverId)
{
if (!prmIsDefault(_value))
{
receiverId = _value;
}
return receiverId;
}
/// <summary>
/// countryCode
/// </summary>
/// <param name = "_value">countryCode</param>
/// <returns>countryCode</returns>
[DataMember("countryCode")]
public str parmCountryCode(str _value = countryCode)
{
if (!prmIsDefault(_value))
{
countryCode = _value;
}
return countryCode;
}
/// <summary>
/// messageId
/// </summary>
/// <param name = "_value">messageId</param>
/// <returns>messageId</returns>
[DataMember("messageId")]
public str parmMessageId(str _value = messageId)
{
if (!prmIsDefault(_value))
{
messageId = _value;
}
return messageId;
}
/// <summary>
/// dateTime
/// </summary>
/// <param name = "_value">dateTime</param>
/// <returns>dateTime</returns>
[DataMember("dateTime")]
public str parmDateTime(str _value = dateTime)
{
if (!prmIsDefault(_value))
{
dateTime = _value;
}
return dateTime;
}
/// <summary>
/// status
/// </summary>
/// <param name = "_value">status</param>
/// <returns>status</returns>
[DataMember("status")]
public str parmStatus(str _value = status)
{
if (!prmIsDefault(_value))
{
status = _value;
}
return status;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Response
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopResponseContract
{
private str id;
private GopErrorResponseContract error;
/// <summary>
/// id
/// </summary>
/// <param name = "_value">id</param>
/// <returns>id</returns>
[DataMember("id")]
public str parmId(str _value = id)
{
id = _value;
return id;
}
/// <summary>
/// error
/// </summary>
/// <param name = "_value">error</param>
/// <returns>error</returns>
[DataMember("error")]
public GopErrorResponseContract parmError(GopErrorResponseContract _value = error)
{
error = _value;
return error;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Error Response contract
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopErrorResponseContract
{
private str errorCode;
private str errorDescription;
private str errorMessage;
/// <summary>
/// Error Description
/// </summary>
/// <param name = "_value">value</param>
/// <returns>errorDescription</returns>
[DataMember("errorDescription")]
public str parmErrorDescription(str _value = errorDescription)
{
errorDescription = _value;
return errorDescription;
}
/// <summary>
/// Error Code
/// </summary>
/// <param name = "_value">value</param>
/// <returns>Error Code</returns>
[DataMember("errorCode")]
public str parmErrorCode(str _value = errorCode)
{
errorCode = _value;
return errorCode;
}
/// <summary>
/// error message
/// </summary>
/// <param name = "_value">value</param>
/// <returns>error message</returns>
[DataMember("errorMessage")]
public str parmErrorMessage(str _value = errorMessage)
{
errorMessage = _value;
return errorMessage;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Data contract for sales order asn request header outbound interface
/// </summary>
[DataContractAttribute]
class GopEDISORequestHeaderOBContract
{
str channelName;
str senderId;
str receiverId;
str messageId;
str dateTime;
str countryCode;
/// <summary>
/// channelName
/// </summary>
/// <param name = "_channelName">channelName</param>
/// <returns>channelName</returns>
[DataMember('channelName')]
public str parmChannelName(str _channelName = channelName)
{
channelName = _channelName;
return channelName;
}
/// <summary>
/// senderId
/// </summary>
/// <param name = "_senderId">senderId</param>
/// <returns>senderId</returns>
[DataMember('senderId')]
public str parmSenderId(str _senderId = senderId)
{
senderId = _senderId;
return senderId;
}
/// <summary>
/// receiverId
/// </summary>
/// <param name = "_receiverId">receiverId</param>
/// <returns>receiverId</returns>
[DataMember('receiverId')]
public str parmReceiverId(str _receiverId = receiverId)
{
receiverId = _receiverId;
return receiverId;
}
/// <summary>
/// messageId
/// </summary>
/// <param name = "_messageId">messageId</param>
/// <returns>messageId</returns>
[DataMember('messageId')]
public str parmMessageId(str _messageId = messageId)
{
messageId = _messageId;
return messageId;
}
/// <summary>
/// dateTime
/// </summary>
/// <param name = "_dateTime">dateTime</param>
/// <returns>dateTime</returns>
[DataMember('dateTime')]
public str parmDateTime(str _dateTime = dateTime)
{
dateTime = _dateTime;
return dateTime;
}
/// <summary>
/// countryCode
/// </summary>
/// <param name = "_countryCode">countryCode</param>
/// <returns>countryCode</returns>
[DataMember('countryCode')]
public str parmCountryCode(str _countryCode = countryCode)
{
countryCode = _countryCode;
return countryCode;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Asn request
/// </summary>
[DataContractAttribute]
public class GopEDISOASNRequestContract
{
private GopEDISORequestHeaderOBContract asnRequestOBHeader;
private GopEDISOASNHeaderOBContract asnHeaderContract;
/// <summary>
/// requestHeader
/// </summary>
/// <param name = "_asnRequestOBHeader">requestHeader</param>
/// <returns>requestHeader</returns>
[DataMember("requestHeader")]
public GopEDISORequestHeaderOBContract parmASNRequestHeaderOBContract(GopEDISORequestHeaderOBContract _asnRequestOBHeader = asnRequestOBHeader)
{
asnRequestOBHeader = _asnRequestOBHeader;
return asnRequestOBHeader;
}
/// <summary>
/// asnRequest
/// </summary>
/// <param name = "_asnHeaderContract">asnRequest</param>
/// <returns>asnRequest</returns>
[DataMember("asnRequest")]
public GopEDISOASNHeaderOBContract parmASNHeaderOBContract(GopEDISOASNHeaderOBContract _asnHeaderContract = asnHeaderContract)
{
asnHeaderContract = _asnHeaderContract;
return asnHeaderContract;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Data contract for sales order asn order detail outbound interface
/// </summary>
[DataContractAttribute]
public class GopEDISOASNOrderDetailOBContract
{
str orderNumber;
str orderDate;
str supplierOrderReference;
str purchaserOrderReference;
str packingSlipNumber;
str currency;
str specialInstructions;
real totalQuantityOrdered;
real totalQuantityDelivered;
real orderGrossWeight;
str orderGrossWeightUOM;
real orderTotalVolume;
List asnItemDetail = new List(Types::Class);
/// <summary>
/// orderNumber
/// </summary>
/// <param name = "_orderNumber">orderNumber</param>
/// <returns>orderNumber</returns>
[DataMember('orderNumber')]
public str parmOrderNumber(str _orderNumber = orderNumber)
{
orderNumber = _orderNumber;
return orderNumber;
}
/// <summary>
/// orderDate
/// </summary>
/// <param name = "_orderDate">orderDate</param>
/// <returns>orderDate</returns>
[DataMember('orderDate')]
public str parmOrderDate(str _orderDate = orderDate)
{
orderDate = _orderDate;
return orderDate;
}
/// <summary>
/// supplierOrderReference
/// </summary>
/// <param name = "_supplierOrderReference">supplierOrderReference</param>
/// <returns>supplierOrderReference</returns>
[DataMember('supplierOrderReference')]
public str parmSupplierOrderReference(str _supplierOrderReference = supplierOrderReference)
{
supplierOrderReference = _supplierOrderReference;
return supplierOrderReference;
}
/// <summary>
/// purchaserOrderReference
/// </summary>
/// <param name = "_purchaserOrderReference">purchaserOrderReference</param>
/// <returns>purchaserOrderReference</returns>
[DataMember('purchaserOrderReference')]
public str parmPurchaserOrderReference(str _purchaserOrderReference = purchaserOrderReference)
{
purchaserOrderReference = _purchaserOrderReference;
return purchaserOrderReference;
}
/// <summary>
/// packingSlipNumber
/// </summary>
/// <param name = "_packingSlipNumber">packingSlipNumber</param>
/// <returns>packingSlipNumber</returns>
[DataMember('packingSlipNumber')]
public str parmPackingSlipNumber(str _packingSlipNumber = packingSlipNumber)
{
packingSlipNumber = _packingSlipNumber;
return packingSlipNumber;
}
/// <summary>
/// currency
/// </summary>
/// <param name = "_currency">currency</param>
/// <returns>currency</returns>
[DataMember('currency')]
public str parmCurrency(str _currency = currency)
{
currency = _currency;
return currency;
}
/// <summary>
/// specialInstructions
/// </summary>
/// <param name = "_specialInstructions">specialInstructions</param>
/// <returns>specialInstructions</returns>
[DataMember('specialInstructions')]
public str parmSpecialInstructions(str _specialInstructions = specialInstructions)
{
specialInstructions = _specialInstructions;
return specialInstructions;
}
/// <summary>
/// totalQuantityOrdered
/// </summary>
/// <param name = "_totalQuantityOrdered">totalQuantityOrdered</param>
/// <returns>totalQuantityOrdered</returns>
[DataMember('totalQuantityOrdered')]
public real parmTotalQuantityOrdered(real _totalQuantityOrdered = totalQuantityOrdered)
{
totalQuantityOrdered = _totalQuantityOrdered;
return totalQuantityOrdered;
}
/// <summary>
/// totalQuantityDelivered
/// </summary>
/// <param name = "_totalQuantityDeliveredtotalQuantityDeliveredparam>
/// <returns>totalQuantityDelivered</returns>
[DataMember('totalQuantityDelivered')]
public real parmTotalQuantityDelivered(real _totalQuantityDelivered = totalQuantityDelivered)
{
totalQuantityDelivered = _totalQuantityDelivered;
return totalQuantityDelivered;
}
/// <summary>
/// orderGrossWeight
/// </summary>
/// <param name = "_orderGrossWeight">orderGrossWeight</param>
/// <returns>orderGrossWeight</returns>
[DataMember('orderGrossWeight')]
public real parmOrderGrossWeight(real _orderGrossWeight = orderGrossWeight)
{
orderGrossWeight = _orderGrossWeight;
return orderGrossWeight;
}
/// <summary>
/// orderGrossWeightUOM
/// </summary>
/// <param name = "_orderGrossWeightUOM">orderGrossWeightUOM</param>
/// <returns>orderGrossWeightUOM</returns>
[DataMember('orderGrossWeightUOM')]
public str parmOrderGrossWeightUOM(str _orderGrossWeightUOM = orderGrossWeightUOM)
{
orderGrossWeightUOM = _orderGrossWeightUOM;
return orderGrossWeightUOM;
}
/// <summary>
/// orderTotalVolume
/// </summary>
/// <param name = "_orderTotalVolume">orderTotalVolume</param>
/// <returns>orderTotalVolume</returns>
[DataMember('orderTotalVolume')]
public real parmOrderTotalVolume(real _orderTotalVolume = orderTotalVolume)
{
orderTotalVolume = _orderTotalVolume;
return orderTotalVolume;
}
/// <summary>
/// asnItemDetail
/// </summary>
/// <param name = "_asnItemDetail">asnItemDetail</param>
/// <returns>asnItemDetail</returns>
[
DataMember('asnItemDetail'),
AifCollectionTypeAttribute('_asnItemDetail', Types::Class, classStr(GopEDISOASNLineDetailOBContract)),
AifCollectionTypeAttribute('return', Types::Class, classStr(GopEDISOASNLineDetailOBContract))
]
public List parmASNItemDetails(List _asnItemDetail = asnItemDetail)
{
asnItemDetail = _asnItemDetail;
return asnItemDetail;
}
}
-------------------------------------------------------------------------------
// <summary>
/// Data contract for sales order asn line package info detail outbound interface
/// </summary>
[DataContractAttribute]
public class GopEDISOASNLinePackageDetailOBContract
{
str packageNumber;
str expiryDate;
str batchNumber;
real packageWeight;
str weightUnitOfMeasure;
str containerNumber;
/// <summary>
/// packageNumber
/// </summary>
/// <param name = "_packageNumber">packageNumber</param>
/// <returns>packageNumber</returns>
[DataMember('packageNumber')]
public str parmPackageNumber(str _packageNumber = packageNumber)
{
packageNumber = _packageNumber;
return packageNumber;
}
/// <summary>
/// expiryDate
/// </summary>
/// <param name = "_expiryDate">expiryDate</param>
/// <returns>expiryDate</returns>
[DataMember('expiryDate')]
public str parmExpiryDate(str _expiryDate = expiryDate)
{
expiryDate = _expiryDate;
return expiryDate;
}
/// <summary>
/// batchNumber
/// </summary>
/// <param name = "_batchNumber">batchNumber</param>
/// <returns>batchNumber</returns>
[DataMember('batchNumber')]
public str parmBatchNumber(str _batchNumber = batchNumber)
{
batchNumber = _batchNumber;
return batchNumber;
}
/// <summary>
/// packageWeight
/// </summary>
/// <param name = "_packageWeight">packageWeight</param>
/// <returns>packageWeight</returns>
[DataMember('packageWeight')]
public real parmPackageWeight(real _packageWeight = packageWeight)
{
packageWeight = _packageWeight;
return packageWeight;
}
/// <summary>
/// weightUnitOfMeasure
/// </summary>
/// <param name = "_weightUnitOfMeasure">weightUnitOfMeasure</param>
/// <returns>weightUnitOfMeasure</returns>
[DataMember('weightUnitOfMeasure')]
public str parmWeightUnitOfMeasure(str _weightUnitOfMeasure = weightUnitOfMeasure)
{
weightUnitOfMeasure = _weightUnitOfMeasure;
return weightUnitOfMeasure;
}
/// <summary>
/// containerNumber
/// </summary>
/// <param name = "_containerNumber">containerNumber</param>
/// <returns>containerNumber</returns>
[DataMember('containerNumber')]
public str parmContainerNumber(str _containerNumber = containerNumber)
{
containerNumber = _containerNumber;
return containerNumber;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Data contract for sales order asn line detail outbound interface
/// </summary>
[DataContract]
public class GopEDISOASNLineDetailOBContract
{
real orderLineNumber;
str supplierItemCode;
str originatorItemCode;
str eanItemCode;
str supplierItemDescription;
real quantityOrdered;
str unitOfMeasure;
str unitOfMeasureType;
real quantityforDelivery;
str documentNumber;
real documentLine;
str supplierDocumentNumber;
real supplierDocumentLine;
real totalWeight;
str weightUnitOfMeasure;
real totalVolume;
real unitPriceBeforeDiscount;
real unitPriceAfterDiscount;
str priceUnitOfMeasure;
str priceUnitOfMeasureType;
real linePrice;
List asnItemPackageInfo = new List(Types::Class);
/// <summary>
/// orderLineNumber
/// </summary>
/// <param name = "_orderLineNumber">orderLineNumber</param>
/// <returns>orderLineNumber</returns>
[DataMember('orderLineNumber')]
public real parmOrderLineNumber(real _orderLineNumber = orderLineNumber)
{
orderLineNumber = _orderLineNumber;
return orderLineNumber;
}
/// <summary>
/// supplierItemCode
/// </summary>
/// <param name = "_supplierItemCode">supplierItemCode</param>
/// <returns>supplierItemCode</returns>
[DataMember('supplierItemCode')]
public str parmSupplierItemCode(str _supplierItemCode = supplierItemCode)
{
supplierItemCode = _supplierItemCode;
return supplierItemCode;
}
/// <summary>
/// originatorItemCode
/// </summary>
/// <param name = "_originatorItemCode">originatorItemCode</param>
/// <returns>originatorItemCode</returns>
[DataMember('originatorItemCode')]
public str parmOriginatorItemCode(str _originatorItemCode = originatorItemCode)
{
originatorItemCode = _originatorItemCode;
return originatorItemCode;
}
/// <summary>
/// partyAddressLine1
/// </summary>
/// <param name = "_eanItemCode">partyAddressLine1</param>
/// <returns>partyAddressLine1</returns>
[DataMember('partyAddressLine1')]
public str parmEanItemCode(str _eanItemCode = eanItemCode)
{
eanItemCode = _eanItemCode;
return eanItemCode;
}
/// <summary>
/// supplierItemDescription
/// </summary>
/// <param name = "_supplierItemDescription">supplierItemDescription</param>
/// <returns>supplierItemDescription</returns>
[DataMember('supplierItemDescription')]
public str parmSupplierItemDescription(str _supplierItemDescription = supplierItemDescription)
{
supplierItemDescription = _supplierItemDescription;
return supplierItemDescription;
}
/// <summary>
/// quantityOrdered
/// </summary>
/// <param name = "_quantityOrdered">quantityOrdered</param>
/// <returns>quantityOrdered</returns>
[DataMember('quantityOrdered')]
public real parmQuantityOrdered(real _quantityOrdered = quantityOrdered)
{
quantityOrdered = _quantityOrdered;
return quantityOrdered;
}
/// <summary>
/// unitOfMeasure
/// </summary>
/// <param name = "_unitOfMeasure">unitOfMeasure</param>
/// <returns>unitOfMeasure</returns>
[DataMember('unitOfMeasure')]
public str parmUnitOfMeasure(str _unitOfMeasure = unitOfMeasure)
{
unitOfMeasure = _unitOfMeasure;
return unitOfMeasure;
}
/// <summary>
/// unitOfMeasureType
/// </summary>
/// <param name = "_unitOfMeasureType">unitOfMeasureType</param>
/// <returns>unitOfMeasureType</returns>
[DataMember('unitOfMeasureType')]
public str parmUnitOfMeasureType(str _unitOfMeasureType = unitOfMeasureType)
{
unitOfMeasureType = _unitOfMeasureType;
return unitOfMeasureType;
}
/// <summary>
/// quantityforDelivery
/// </summary>
/// <param name = "_quantityforDelivery">quantityforDelivery</param>
/// <returns>quantityforDelivery</returns>
[DataMember('quantityforDelivery')]
public real parmQuantityforDelivery(real _quantityforDelivery = quantityforDelivery)
{
quantityforDelivery = _quantityforDelivery;
return quantityforDelivery;
}
/// <summary>
/// documentNumber
/// </summary>
/// <param name = "_documentNumber">documentNumber</param>
/// <returns>documentNumber</returns>
[DataMember('documentNumber')]
public str parmDocumentNumber(str _documentNumber = documentNumber)
{
documentNumber = _documentNumber;
return documentNumber;
}
/// <summary>
/// documentLine
/// </summary>
/// <param name = "_documentLine">documentLine</param>
/// <returns>documentLine</returns>
[DataMember('documentLine')]
public real parmDocumentLine(real _documentLine = documentLine)
{
documentLine = _documentLine;
return documentLine;
}
/// <summary>
/// supplierDocumentNumber
/// </summary>
/// <param name = "_supplierDocumentNumber">supplierDocumentNumber</param>
/// <returns>supplierDocumentNumber</returns>
[DataMember('supplierDocumentNumber')]
public str parmSupplierDocumentNumber(str _supplierDocumentNumber = supplierDocumentNumber)
{
supplierDocumentNumber = _supplierDocumentNumber;
return supplierDocumentNumber;
}
/// <summary>
/// supplierDocumentLine
/// </summary>
/// <param name = "_supplierDocumentLine">supplierDocumentLine</param>
/// <returns>supplierDocumentLine</returns>
[DataMember('supplierDocumentLine')]
public real parmSupplierDocumentLine(real _supplierDocumentLine = supplierDocumentLine)
{
supplierDocumentLine = _supplierDocumentLine;
return supplierDocumentLine;
}
/// <summary>
/// totalWeight
/// </summary>
/// <param name = "_totalWeight">totalWeight</param>
/// <returns>totalWeight</returns>
[DataMember('totalWeight')]
public real parmTotalWeight(real _totalWeight = totalWeight)
{
totalWeight = _totalWeight;
return totalWeight;
}
/// <summary>
/// weightUnitOfMeasure
/// </summary>
/// <param name = "_weightUnitOfMeasure">weightUnitOfMeasure</param>
/// <returns>weightUnitOfMeasure</returns>
[DataMember('weightUnitOfMeasure')]
public str parmWeightUnitOfMeasure(str _weightUnitOfMeasure = weightUnitOfMeasure)
{
weightUnitOfMeasure = _weightUnitOfMeasure;
return weightUnitOfMeasure;
}
/// <summary>
/// totalVolume
/// </summary>
/// <param name = "_totalVolume">totalVolume</param>
/// <returns>totalVolume</returns>
[DataMember('totalVolume')]
public real parmTotalVolume(real _totalVolume = totalVolume)
{
totalVolume = _totalVolume;
return totalVolume;
}
/// <summary>
/// unitPriceBeforeDiscount
/// </summary>
/// <param name = "_unitPriceBeforeDiscount">unitPriceBeforeDiscount</param>
/// <returns>unitPriceBeforeDiscount</returns>
[DataMember('unitPriceBeforeDiscount')]
public real parmUnitPriceBeforeDiscount(real _unitPriceBeforeDiscount = unitPriceBeforeDiscount)
{
unitPriceBeforeDiscount = _unitPriceBeforeDiscount;
return unitPriceBeforeDiscount;
}
/// <summary>
/// unitPriceAfterDiscount
/// </summary>
/// <param name = "_unitPriceAfterDiscount">unitPriceAfterDiscount</param>
/// <returns>unitPriceAfterDiscount</returns>
[DataMember('unitPriceAfterDiscount')]
public real parmUnitPriceAfterDiscount(real _unitPriceAfterDiscount = unitPriceAfterDiscount)
{
unitPriceAfterDiscount = _unitPriceAfterDiscount;
return unitPriceAfterDiscount;
}
/// <summary>
/// priceUnitOfMeasure
/// </summary>
/// <param name = "_priceUnitOfMeasure">priceUnitOfMeasure</param>
/// <returns>priceUnitOfMeasure</returns>
[DataMember('priceUnitOfMeasure')]
public str parmPriceUnitOfMeasure(str _priceUnitOfMeasure = priceUnitOfMeasure)
{
priceUnitOfMeasure = _priceUnitOfMeasure;
return priceUnitOfMeasure;
}
/// <summary>
/// priceUnitOfMeasureType
/// </summary>
/// <param name = "_priceUnitOfMeasureType">priceUnitOfMeasureType</param>
/// <returns>priceUnitOfMeasureType</returns>
[DataMember('priceUnitOfMeasureType')]
public str parmPriceUnitOfMeasureType(str _priceUnitOfMeasureType = priceUnitOfMeasureType)
{
priceUnitOfMeasureType = _priceUnitOfMeasureType;
return priceUnitOfMeasureType;
}
/// <summary>
/// linePrice
/// </summary>
/// <param name = "_linePrice">linePrice</param>
/// <returns>linePrice</returns>
[DataMember('linePrice')]
public real parmLinePrice(real _linePrice = linePrice)
{
linePrice = _linePrice;
return linePrice;
}
/// <summary>
/// asnItemPackageInfo
/// </summary>
/// <param name = "_asnItemPackageInfoasnItemPackageInfoparam>
/// <returns>asnItemPackageInfo</returns>
[
DataMember('asnItemPackageInfo'),
AifCollectionTypeAttribute('_asnItemPackageInfo', Types::Class, classStr(GopEDISOASNLinePackageDetailOBContract)),
AifCollectionTypeAttribute('return', Types::Class, classStr(GopEDISOASNLinePackageDetailOBContract))
]
public List parmASNItemPackageInfo(List _asnItemPackageInfo = asnItemPackageInfo)
{
asnItemPackageInfo = _asnItemPackageInfo;
return asnItemPackageInfo;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Data contract for sales order asn header outbound interface
/// </summary>
[DataContractAttribute]
public class GopEDISOASNHeaderOBContract
{
str asnDocumentNumber;
str asnDocumentDate;
str estimatedDepartureDate;
str estimatedArrivalDate;
str documentReference;
str packingSlipNumber;
str countryOfDestination;
str specialInstructions;
real grossWeight;
str grossWeightUOM;
real totalVolume;
str totalVolumeUOM;
List asnParties = new List(Types::Class);
List asnOrderDetail = new List(Types::Class);
/// <summary>
/// asnDocumentNumber
/// </summary>
/// <param name = "_asnDocumentNumber">asnDocumentNumber</param>
/// <returns>asnDocumentNumber</returns>
[DataMember('asnDocumentNumber')]
public str parmASNDocumentNumber(str _asnDocumentNumber = asnDocumentNumber)
{
asnDocumentNumber = _asnDocumentNumber;
return asnDocumentNumber;
}
/// <summary>
/// asnDocumentDate
/// </summary>
/// <param name = "_asnDocumentDate">asnDocumentDate</param>
/// <returns>asnDocumentDate</returns>
[DataMember('asnDocumentDate')]
public str parmASNDocumentDate(str _asnDocumentDate = asnDocumentDate)
{
asnDocumentDate = _asnDocumentDate;
return asnDocumentDate;
}
/// <summary>
/// estimatedDepartureDate
/// </summary>
/// <param name = "_estimatedDepartureDate">estimatedDepartureDate</param>
/// <returns>estimatedDepartureDate</returns>
[DataMember('estimatedDepartureDate')]
public str parmEstimatedDepartureDate(str _estimatedDepartureDate = estimatedDepartureDate)
{
estimatedDepartureDate = _estimatedDepartureDate;
return estimatedDepartureDate;
}
/// <summary>
/// estimatedArrivalDate
/// </summary>
/// <param name = "_estimatedArrivalDate">estimatedArrivalDate</param>
/// <returns>estimatedArrivalDate</returns>
[DataMember('estimatedArrivalDate')]
public str parmEstimatedArrivalDate(str _estimatedArrivalDate = estimatedArrivalDate)
{
estimatedArrivalDate = _estimatedArrivalDate;
return estimatedArrivalDate;
}
/// <summary>
/// documentReference
/// </summary>
/// <param name = "_documentReference">documentReference</param>
/// <returns>documentReference</returns>
[DataMember('documentReference')]
public str parmDocumentReference(str _documentReference = documentReference)
{
documentReference = _documentReference;
return documentReference;
}
/// <summary>
/// packingSlipNumber
/// </summary>
/// <param name = "_packingSlipNumber">packingSlipNumber</param>
/// <returns>packingSlipNumber</returns>
[DataMember('packingSlipNumber')]
public str parmPackingSlipNumber(str _packingSlipNumber = packingSlipNumber)
{
packingSlipNumber = _packingSlipNumber;
return packingSlipNumber;
}
/// <summary>
/// countryOfDestination
/// </summary>
/// <param name = "_countryOfDestination">countryOfDestination</param>
/// <returns>countryOfDestination</returns>
[DataMember('countryOfDestination')]
public str parmCountryOfDestination(str _countryOfDestination = countryOfDestination)
{
countryOfDestination = _countryOfDestination;
return countryOfDestination;
}
/// <summary>
/// specialInstructions
/// </summary>
/// <param name = "_specialInstructions">specialInstructions</param>
/// <returns>specialInstructions</returns>
[DataMember('specialInstructions')]
public str parmSpecialInstructions(str _specialInstructions = specialInstructions)
{
specialInstructions = _specialInstructions;
return specialInstructions;
}
/// <summary>
/// grossWeight
/// </summary>
/// <param name = "_grossWeight">grossWeight</param>
/// <returns>grossWeight</returns>
[DataMember('grossWeight')]
public real parmGrossWeight(real _grossWeight = grossWeight)
{
grossWeight = _grossWeight;
return grossWeight;
}
/// <summary>
/// grossWeightUOM
/// </summary>
/// <param name = "_grossWeightUOM">grossWeightUOM</param>
/// <returns>grossWeightUOM</returns>
[DataMember('grossWeightUOM')]
public str parmGrossWeightUOM(str _grossWeightUOM = grossWeightUOM)
{
grossWeightUOM = _grossWeightUOM;
return grossWeightUOM;
}
/// <summary>
/// totalVolume
/// </summary>
/// <param name = "_totalVolume">totalVolume</param>
/// <returns>totalVolume</returns>
[DataMember('totalVolume')]
public real parmTotalVolume(real _totalVolume = totalVolume)
{
totalVolume = _totalVolume;
return totalVolume;
}
/// <summary>
/// totalVolumeUOM
/// </summary>
/// <param name = "_totalVolumeUOM">totalVolumeUOM</param>
/// <returns>totalVolumeUOM</returns>
[DataMember('totalVolumeUOM')]
public str parmTotalVolumeUOM(str _totalVolumeUOM = totalVolumeUOM)
{
totalVolumeUOM = _totalVolumeUOM;
return totalVolumeUOM;
}
/// <summary>
/// asnParties
/// </summary>
/// <param name = "_asnParties">asnParties</param>
/// <returns>asnParties</returns>
[
DataMember('asnParties'),
AifCollectionTypeAttribute('_asnParties', Types::Class, classStr(GopEDISOASNHeaderAddressOBContract)),
AifCollectionTypeAttribute('return', Types::Class, classStr(GopEDISOASNHeaderAddressOBContract))
]
public List parmASNParties(List _asnParties = asnParties)
{
asnParties = _asnParties;
return asnParties;
}
/// <summary>
/// asnOrderDetail
/// </summary>
/// <param name = "_asnOrderDetail">asnOrderDetail</param>
/// <returns>asnOrderDetail</returns>
[
DataMember('asnOrderDetail'),
AifCollectionTypeAttribute('_asnOrderDetail', Types::Class, classStr(GopEDISOASNOrderDetailOBContract)),
AifCollectionTypeAttribute('return', Types::Class, classStr(GopEDISOASNOrderDetailOBContract))
]
public List parmASNOrderDetail(List _asnOrderDetail = asnOrderDetail)
{
asnOrderDetail = _asnOrderDetail;
return asnOrderDetail;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Data contract for sales order asn header address outbound interface
/// </summary>
[DataContractAttribute]
public class GopEDISOASNHeaderAddressOBContract
{
str partyType;
str partyID;
str partyName;
str partyAddressLine1;
str partyAddressLine2;
str city;
str state;
str postalCode;
str country;
str partyContactName;
str phone;
str faxNumber;
str emailAddress;
/// <summary>
/// _partyType
/// </summary>
/// <param name = "_partyType">_partyType</param>
/// <returns>_partyType</returns>
[DataMember('partyType')]
public str parmPartyType(str _partyType = partyType)
{
partyType = _partyType;
return partyType;
}
/// <summary>
/// partyID
/// </summary>
/// <param name = "_partyID">partyID</param>
/// <returns>partyID</returns>
[DataMember('partyID')]
public str parmPartyID(str _partyID = partyID)
{
partyID = _partyID;
return partyID;
}
/// <summary>
/// partyName
/// </summary>
/// <param name = "_partyName">partyName</param>
/// <returns>partyName</returns>
[DataMember('partyName')]
public str parmPartyName(str _partyName = partyName)
{
partyName = _partyName;
return partyName;
}
/// <summary>
/// partyAddressLine1
/// </summary>
/// <param name = "_partyAddressLine1">partyAddressLine1</param>
/// <returns>partyAddressLine1</returns>
[DataMember('partyAddressLine1')]
public str parmPartyAddressLine1(str _partyAddressLine1 = partyAddressLine1)
{
partyAddressLine1 = _partyAddressLine1;
return partyAddressLine1;
}
/// <summary>
/// partyAddressLine2
/// </summary>
/// <param name = "_partyAddressLine2">partyAddressLine2</param>
/// <returns>partyAddressLine2</returns>
[DataMember('partyAddressLine2')]
public str parmPartyAddressLine2(str _partyAddressLine2 = partyAddressLine2)
{
partyAddressLine2 = _partyAddressLine2;
return partyAddressLine2;
}
/// <summary>
/// city
/// </summary>
/// <param name = "_city">city</param>
/// <returns>city</returns>
[DataMember('city')]
public str parmCity(str _city = city)
{
city = _city;
return city;
}
/// <summary>
/// state
/// </summary>
/// <param name = "_state">state</param>
/// <returns>state</returns>
[DataMember('state')]
public str parmState(str _state = state)
{
state = _state;
return state;
}
/// <summary>
/// postalCode
/// </summary>
/// <param name = "_postalCode">postalCode</param>
/// <returns>postalCode</returns>
[DataMember('postalCode')]
public str parmpPostalCode(str _postalCode = postalCode)
{
postalCode = _postalCode;
return postalCode;
}
/// <summary>
/// country
/// </summary>
/// <param name = "_country">country</param>
/// <returns>country</returns>
[DataMember('country')]
public str parmCountry(str _country = country)
{
country = _country;
return country;
}
/// <summary>
/// partyContactName
/// </summary>
/// <param name = "_partyContactName">partyContactName</param>
/// <returns>partyContactName</returns>
[DataMember('partyContactName')]
public str parmPartyContactName(str _partyContactName = partyContactName)
{
partyContactName = _partyContactName;
return partyContactName;
}
/// <summary>
/// phone
/// </summary>
/// <param name = "_phone">phone</param>
/// <returns>phone</returns>
[DataMember('phone')]
public str parmPhone(str _phone = phone)
{
phone = _phone;
return phone;
}
/// <summary>
/// faxNumber
/// </summary>
/// <param name = "_faxNumber">faxNumber</param>
/// <returns>faxNumber</returns>
[DataMember('faxNumber')]
public str parmFaxNumber(str _faxNumber = faxNumber)
{
faxNumber = _faxNumber;
return faxNumber;
}
/// <summary>
/// emailAddress
/// </summary>
/// <param name = "_emailAddress">emailAddress</param>
/// <returns>emailAddress</returns>
[DataMember('emailAddress')]
public str parmEmailAddress(str _emailAddress = emailAddress)
{
emailAddress = _emailAddress;
return emailAddress;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Gopentum ASN service.
/// </summary>
public class GopASNService
{
private CustPackingSlipJour custPackingSlipJour;
private SalesTable salesTable;
private GopEDISOASNRequestContract request;
RetailWebResponse webResponse;
/// <summary>
/// Packing slip jour
/// </summary>
/// <param name = "_packingSlipJour">custPackingSlipJour</param>
/// <returns>custPackingSlipJour</returns>
public CustPackingSlipJour parmCustPackingSlipJour(CustPackingSlipJour _packingSlipJour = custPackingSlipJour)
{
custPackingSlipJour = _packingSlipJour;
return custPackingSlipJour;
}
/// <summary>
/// Execute - Main mapping logic
/// </summary>
public void execute()
{
GopEDISOASNHeaderAddressOBContract parties;
GopEDISOASNHeaderOBContract asnRequest = new GopEDISOASNHeaderOBContract();
GopEDISOASNLineDetailOBContract asnItemDetail;
GopEDISOASNLinePackageDetailOBContract asnItemPackageInfo;
GopEDISOASNOrderDetailOBContract asnOrderDetail;
GopEDISORequestHeaderOBContract requestHeader;
SalesTotals salesTotals = SalesTotals::construct(salesTable, SalesUpdate::PackingSlip);
salesTotals.calc();
List asnParties = new List(Types::Class);
List asnOrderDetails = new List(Types::Class);
List asnItemPackageInfos = new List(Types::Class);
List asnItemDetails = new List(Types::Class);
str formatDate(TransDate _date)
{
str formatDate = date2Str(_date, 321, 2, DateSeparator::Hyphen, 2, DateSeparator::Hyphen, 4);
return formatDate;
}
request = new GopEDISOASNRequestContract();
// Populating request header
requestHeader = new GopEDISORequestHeaderOBContract();
requestHeader.parmChannelName(salesTable.GopEDITrandingPartnerId);
requestHeader.parmCountryCode(curExt());
requestHeader.parmDateTime(DateTimeUtil::toStr(DateTimeUtil::getSystemDateTime()));
requestHeader.parmMessageId(strrem(guid2str(newguid()), '{}'));//guid2StrWithoutBraces(any2Guid(custPackingSlipJour.PackingSlipId)));
requestHeader.parmReceiverId(salesTable.GopSourceSystemIdentifier);
requestHeader.parmSenderId(salesTable.GopRecipientSystemIdentifier);
//Adding request header to request
request.parmASNRequestHeaderOBContract(requestHeader);
//Populating ASNRequest
asnRequest.parmASNDocumentDate(formatDate(custPackingSlipJour.DeliveryDate));
asnRequest.parmASNDocumentNumber(custPackingSlipJour.PackingSlipId);
asnRequest.parmCountryOfDestination(LogisticsAddressCountryRegion::find(custPackingSlipJour.postalAddress().CountryRegionId).displayName());
asnRequest.parmDocumentReference(salesTable.SalesId);
asnRequest.parmEstimatedArrivalDate(formatDate(salesTable.ReceiptDateRequested));
asnRequest.parmEstimatedDepartureDate(formatDate(salesTable.ShippingDateRequested));
asnRequest.parmGrossWeight(salesTotals.totalWeight());
asnRequest.parmGrossWeightUOM(); //Need to clarify
asnRequest.parmPackingSlipNumber(custPackingSlipJour.PackingSlipId);
asnRequest.parmSpecialInstructions(subStr(salesTable.GopSpecialInstructionCustomer, 1, 350));
asnRequest.parmTotalVolume(salesTotals.totalVolume());
asnRequest.parmTotalVolumeUOM(); //Need to clarify
SalesLine salesLineST;
select firstonly salesLineST
where salesLineST.SalesId == SalesTable.SalesId;
LogisticsPostalAddress postalAddress = salesLineST.deliveryAddress();
LogisticsLocation location = LogisticsLocation::find(postalAddress.Location);
LogisticsAddressCountryRegion country = LogisticsAddressCountryRegion::find(postalAddress.CountryRegionId);
LogisticsAddressState state = LogisticsAddressState::find(postalAddress.CountryRegionId, postalAddress.State);
LogisticsAddressCity city = LogisticsAddressCity::find(postalAddress.City);
LogisticsElectronicAddress fax = DirParty::primaryElectronicAddress(salesTable.custTable_CustAccount().Party, LogisticsElectronicAddressMethodType::Fax);
//Populate Parties - ShipTO
parties = new GopEDISOASNHeaderAddressOBContract();
parties.parmPartyType("ST");
parties.parmPartyID(salesTable.GopShipToNumber);
parties.parmCity(city.Name);
parties.parmCountry(country.displayName());
parties.parmEmailAddress(subStr(salesTable.customerEmail(), 1, 50));
parties.parmFaxNumber(fax.Locator);
parties.parmPartyAddressLine1(subStr(postalAddress.Street, 1, 35));
parties.parmPartyAddressLine2(postalAddress.PostBox);
parties.parmPartyContactName(subStr(salesTable.contactPersonName(),1,35));
parties.parmPartyName(subStr(location.Description, 1, 35));
parties.parmPhone(salesTable.customerPhone());
parties.parmState(state.Name);
parties.parmpPostalCode(postalAddress.ZipCode);
asnParties.addEnd(parties);
postalAddress = null;
location = null;
country = null;
state = null;
city = null;
fax = null;
postalAddress = salesTable.deliveryAddress();
location = LogisticsLocation::find(postalAddress.Location);
country = LogisticsAddressCountryRegion::find(postalAddress.CountryRegionId);
state = LogisticsAddressState::find(postalAddress.CountryRegionId, postalAddress.State);
city = LogisticsAddressCity::find(postalAddress.City);
fax = DirParty::primaryElectronicAddress(salesTable.custTable_InvoiceAccount().Party, LogisticsElectronicAddressMethodType::Fax);
// BY
parties = new GopEDISOASNHeaderAddressOBContract();
parties.parmPartyType("PUR");
parties.parmPartyID(salesTable.GopBuyer);
parties.parmCity(city.Name);
parties.parmCountry(country.displayName());
parties.parmEmailAddress(subStr(salesTable.customerEmail(), 1, 50));
parties.parmFaxNumber(fax.Locator);
parties.parmPartyAddressLine1(subStr(postalAddress.Street, 1, 35));
parties.parmPartyAddressLine2(postalAddress.PostBox);
parties.parmPartyContactName(subStr(salesTable.contactPersonName(),1,35));
parties.parmPartyName(subStr(location.Description, 1, 35));
parties.parmPhone(salesTable.customerPhone());
parties.parmState(state.Name);
parties.parmpPostalCode(postalAddress.ZipCode);
asnParties.addEnd(parties);
postalAddress = null;
location = null;
country = null;
state = null;
city = null;
fax = null;
PurchTable purchTable = salesTable.referencePurchTable();
Email email;
if (!purchTable)
{
SalesLine salesLinePurch;
select firstonly salesLinePurch
where salesLinePurch.SalesId == SalesTable.SalesId;
purchTable = salesLinePurch.referencedPurchLine().purchTable();
}
PartyName partyName;
VendAccount partyId;
if (purchTable)
{
postalAddress = purchTable.deliveryAddress();
location = LogisticsLocation::find(postalAddress.Location);
country = LogisticsAddressCountryRegion::find(postalAddress.CountryRegionId);
state = LogisticsAddressState::find(postalAddress.CountryRegionId, postalAddress.State);
city = LogisticsAddressCity::find(postalAddress.City);
email = DirParty::primaryElectronicAddress(purchTable.vendTable_OrderAccount().Party, LogisticsElectronicAddressMethodType::Email).Locator;
partyId = purchTable.OrderAccount;
partyName = purchTable.vendorName();
}
else
{
postalAddress = CompanyInfo::find().postalAddress();
location = LogisticsLocation::find(postalAddress.Location);
country = LogisticsAddressCountryRegion::find(postalAddress.CountryRegionId);
state = LogisticsAddressState::find(postalAddress.CountryRegionId, postalAddress.State);
city = LogisticsAddressCity::find(postalAddress.City);
partyName = HcmWorker::find(salesTable.WorkerSalesResponsible).name();
partyId = curExt();
email = HcmWorker::find(salesTable.WorkerSalesResponsible).email();
fax = DirParty::primaryElectronicAddress(CompanyInfo::find().RecId, LogisticsElectronicAddressMethodType::Fax);
}
//SU
parties = new GopEDISOASNHeaderAddressOBContract();
parties.parmPartyType("SUP");
parties.parmPartyID(partyId);
parties.parmCity(city.Name);
parties.parmCountry(country.displayName());
parties.parmEmailAddress(subStr(email, 1,50));
parties.parmPartyAddressLine1(subStr(postalAddress.Street, 1, 35));
parties.parmPartyAddressLine2(postalAddress.PostBox);
parties.parmPartyContactName(subStr(partyName,1,35));
parties.parmPartyName(subStr(location.Description, 1, 35));
parties.parmPhone(); // todo
parties.parmState(state.Name);
parties.parmpPostalCode(postalAddress.ZipCode);
asnParties.addEnd(parties);
//Add parties to asnRequest
asnRequest.parmASNParties(asnParties);
asnOrderDetail = new GopEDISOASNOrderDetailOBContract();
asnOrderDetail.parmOrderNumber(salesTable.SalesId);
asnOrderDetail.parmOrderDate(formatDate(salesTable.createDate()));
asnOrderDetail.parmSupplierOrderReference(salesTable.CustomerRef);
asnOrderDetail.parmPurchaserOrderReference(salesTable.SalesId);
asnOrderDetail.parmPackingSlipNumber(custPackingSlipJour.PackingSlipId);
asnOrderDetail.parmCurrency(salesTable.CurrencyCode);
asnOrderDetail.parmSpecialInstructions(SalesTable.GopSpecialInstructionCustomer);
asnOrderDetail.parmTotalQuantityOrdered();
asnOrderDetail.parmTotalQuantityDelivered();
asnOrderDetail.parmOrderGrossWeight(salesTotals.totalGrossWeight());
asnOrderDetail.parmOrderGrossWeightUOM();// Need to check
asnOrderDetail.parmOrderTotalVolume(salesTotals.totalVolume());
CustPackingSlipTrans custPackingSlipTrans;
SalesLine salesLine;
GopCustomerItemXReference custItemRef;
while select custPackingSlipTrans
where custPackingSlipTrans.PackingSlipId == custPackingSlipJour.PackingSlipId &&
custPackingSlipTrans.SalesId == custPackingSlipJour.SalesId
join salesLine
where salesLine.InventTransId == custPackingSlipTrans.InventTransId
{
select firstOnly custItemRef
where custItemRef.CustomerPartNumber == salesLine.GopCustomerPartNumber &&
custItemRef.CustomerID == salesLine.CustAccount &&
custItemRef.ItemId == salesLine.ItemId &&
custItemRef.CustomerOrderUOM == salesLine.GopCustomerOrderUOM;
if (!custItemRef)
{
select firstOnly custItemRef
where (custItemRef.CatalogueNumber == salesLine.GopCatalogueNumber ||
custItemRef.GTINNumber == salesLine.GopGTINNumber) &&
custItemRef.ItemId == salesLine.ItemId;
}
asnItemDetail = new GopEDISOASNLineDetailOBContract();
SalesPrice salesPrice = salesLine.SalesPrice;
InventTable inventTable = custPackingSlipTrans.inventTable();
asnItemDetail.parmDocumentLine(custPackingSlipTrans.LineNum);
asnItemDetail.parmDocumentNumber(custPackingSlipTrans.PackingSlipId);
asnItemDetail.parmEanItemCode(custPackingSlipTrans.ItemId);
asnItemDetail.parmLinePrice(custPackingSlipTrans.AmountCur);
asnItemDetail.parmOrderLineNumber(salesLine.GopEDILineNum ? salesLine.GopEDILineNum :salesLine.LineNum);
asnItemDetail.parmOriginatorItemCode(custItemRef.CustomerPartNumber);
System.Double priceUnit = salesLine.PriceUnit;
asnItemDetail.parmPriceUnitOfMeasure(salesLine.GopCustomerOrderUOM ? salesLine.GopCustomerOrderUOM : salesLine.SalesUnit); // need to check
asnItemDetail.parmPriceUnitOfMeasureType(); // Need to check
asnItemDetail.parmSupplierDocumentLine(custPackingSlipTrans.LineNum);
asnItemDetail.parmSupplierDocumentNumber(custPackingSlipJour.PackingSlipId);
asnItemDetail.parmSupplierItemCode(custPackingSlipTrans.ItemId);
asnItemDetail.parmSupplierItemDescription(salesLine.Name);
asnItemDetail.parmTotalVolume(inventTable.grossVolume() * custPackingSlipTrans.Qty);
asnItemDetail.parmTotalWeight(inventTable.grossWeight() * custPackingSlipTrans.Qty);
asnItemDetail.parmUnitOfMeasure(salesLine.GopCustomerOrderUOM ? salesLine.GopCustomerOrderUOM : salesLine.SalesUnit);
asnItemDetail.parmPriceUnitOfMeasure(GopEskerEDIUOMTransformation::transformUOM(salesTable.CustAccount, salesTable.GopSourceSystemIdentifier, asnItemDetail.parmPriceUnitOfMeasure()));
asnItemDetail.parmUnitOfMeasure(GopEskerEDIUOMTransformation::transformUOM(salesTable.CustAccount, salesTable.GopSourceSystemIdentifier, asnItemDetail.parmUnitOfMeasure()));
if (custItemRef.CustomerConversionFactor)
{
asnItemDetail.parmQuantityforDelivery(custPackingSlipTrans.Qty / custItemRef.CustomerConversionFactor);
salesPrice = salesPrice*custItemRef.CustomerConversionFactor;
}
else if (custItemRef.BaseConversionFactor)
{
asnItemDetail.parmQuantityforDelivery(custPackingSlipTrans.Qty * custItemRef.BaseConversionFactor);
salesPrice = salesPrice/custItemRef.BaseConversionFactor;
}
else
{
asnItemDetail.parmQuantityforDelivery(custPackingSlipTrans.Qty);
}
asnItemDetail.parmQuantityOrdered(salesLine.GopCustomerOrderQty);
asnItemDetail.parmUnitOfMeasureType();
if (salesLine.discAmount())
{
asnItemDetail.parmUnitPriceAfterDiscount(salesPrice + (salesLine.discAmount()/salesLine.QtyOrdered));
}
asnItemDetail.parmUnitPriceBeforeDiscount(salesPrice);
asnItemDetail.parmWeightUnitOfMeasure();
asnItemPackageInfo = new GopEDISOASNLinePackageDetailOBContract();
InventTransOrigin transOrigin;
InventTrans inventTrans;
while select transOrigin
where transOrigin.InventTransId == custPackingSlipTrans.InventTransId
join inventTrans
where inventTrans.InventTransOrigin == transOrigin.RecId &&
inventTrans.PackingSlipId == custPackingSlipTrans.PackingSlipId
{
InventBatch batch = InventBatch::find(inventTrans.inventBatchId(), inventTrans.ItemId);
if (batch)
{
asnItemPackageInfo.parmBatchNumber(inventTrans.inventDim().inventBatchId);
asnItemPackageInfo.parmExpiryDate(formatDate(batch.expDate));
}
else
{
asnItemPackageInfo.parmExpiryDate(formatDate(dateNull()));
}
asnItemPackageInfo.parmContainerNumber(); // Needs to be blank
asnItemPackageInfo.parmPackageNumber("P0000" + "_" + any2Str(real2int(custPackingSlipTrans.LineNum)));
asnItemPackageInfo.parmPackageWeight();
asnItemPackageInfo.parmWeightUnitOfMeasure();
asnItemPackageInfos.addEnd(asnItemPackageInfo);
}
asnItemDetail.parmASNItemPackageInfo(asnItemPackageInfos);
asnItemDetails.addEnd(asnItemDetail);
}
asnOrderDetail.parmASNItemDetails(asnItemDetails);
asnOrderDetails.addEnd(asnOrderDetail);
asnRequest.parmASNOrderDetail(asnOrderDetails);
request.parmASNHeaderOBContract(asnRequest);
}
/// <summary>
/// initFromArgs
/// </summary>
/// <param name = "_args">args</param>
private void initFromArgs(Args _args)
{
if (_args.record() is custPackingSlipJour)
{
this.parmCustPackingSlipJour(_args.record());
salesTable = custPackingSlipJour.salesTable();
}
else
{
throw error(Error::missingRecord(tableStr(CustPackingSlipJour)));
}
}
/// <summary>
/// new API request
/// </summary>
/// <param name = "_args">args</param>
/// <returns>GopASNService</returns>
public static GopASNService newASNRequest(Args _args)
{
GopASNService asnService = new GopASNService();
asnService.initFromArgs(_args);
asnService.execute();
return asnService;
}
/// <summary>
/// production
/// </summary>
/// <returns>boolean</returns>
private boolean isProduction()
{
#define.prod("https://Gopentum-prod.operations.dynamics.com")
boolean ret = false;
var env = Microsoft.Dynamics.ApplicationPlatform.Environment.EnvironmentFactory::GetApplicationEnvironment();
str url = env.Infrastructure.HostUrl;
if (URL == #prod)
{
ret = true;
}
return ret;
}
/// <summary>
/// send to API
/// </summary>
public void sendToAPI()
{
str Json = FormJsonSerializer::serializeClass(request);
GopMulesoftIntegrationParameterOptions options;
CustPackingSlipJour custPackingSlipJourLoc = CustPackingSlipJour::findRecId(custPackingSlipJour.RecId, true);
#define.interface("EDI - ASN")
if (this.isProduction())
{
select firstonly options
where options.SourceType == GopSourceType::ASN &&
options.Environment == GopEnvironment::Prod;
}
else
{
select firstonly options
where options.SourceType == GopSourceType::ASN &&
options.Environment == GopEnvironment::Test;
}
webResponse = GopAPIHelper::sendToAPI(options.URL, options.ClientId, options.ClientSecret, Json, "POST");
ttsbegin;
if (webResponse.parmHttpStatus() == 200)
{
GopMulesoftIntegrationLogTable::createLog(request.parmASNRequestHeaderOBContract().parmMessageId(),
XMLDocDirection::Outbound,
#interface,
custPackingSlipJour.PackingSlipId,
Json,
GopMulesoftIntegrationResponseStatus::Success,
"",
custPackingSlipJour.SalesId,
custPackingSlipJour.OrderAccount,
salesTable.GopShipToNumber,
salesTable.GopBuyer,
salesTable.GopBillToNumber,
salesTable.CustomerRef,
salesTable.GopEDITrandingPartnerId,
request.parmASNRequestHeaderOBContract().parmCountryCode());
custPackingSlipJourLoc.GopIsSentToMulesoft = NoYes::Yes;
custPackingSlipJourLoc.update();
}
else
{
GopResponseRootContract response = FormJsonSerializer::deserializeObject(classNum(GopResponseRootContract), webResponse.parmData());
GopMulesoftIntegrationLogTable::createLog(request.parmASNRequestHeaderOBContract().parmMessageId(),
XMLDocDirection::Outbound,
#interface,
custPackingSlipJour.PackingSlipId,
Json,
GopMulesoftIntegrationResponseStatus::Failure,
response.parmResponse().parmError().parmErrorDescription(),
custPackingSlipJour.SalesId,
custPackingSlipJour.OrderAccount,
salesTable.GopShipToNumber,
salesTable.GopBuyer,
salesTable.GopBillToNumber,
salesTable.CustomerRef,
salesTable.GopEDITrandingPartnerId,
request.parmASNRequestHeaderOBContract().parmCountryCode());
custPackingSlipJourLoc.GopRetryCount += 1;
custPackingSlipJourLoc.update();
}
ttscommit;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Asn request sending service
/// </summary>
public class GopASNRequestProcessingService extends SysOperationServiceBase
{
/// <summary>
/// Processing
/// </summary>
public void processing()
{
ReqRetryCount maxRetryCount = GopIntegrationParameters::find().MaxRetryCount;
CustPackingSlipJour custPackingSlipJour;
SalesTable salesTable;
GopEDITradingPartner tradingPartner;
while select custPackingSlipJour
where custPackingSlipJour.GopRetryCount < maxRetryCount &&
!custPackingSlipJour.GopIsSentToMulesoft // Query needs to be modified once TradingPartner Sub master is developed
exists join salesTable
where salesTable.SalesId == custPackingSlipJour.SalesId
exists join tradingPartner
where tradingPartner.TrandingPartnerId == salesTable.GopEDITrandingPartnerId &&
tradingPartner.ReceiverId == salesTable.GopSourceSystemIdentifier &&
tradingPartner.ASN
{
Args args = new Args();
args.record(custPackingSlipJour);
GopASNService asnService = GopASNService::newASNRequest(args);
asnService.sendToAPI();
}
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Error Response contract
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopErrorResponseContract
{
private str errorCode;
private str errorDescription;
private str errorMessage;
/// <summary>
/// Error Description
/// </summary>
/// <param name = "_value">value</param>
/// <returns>errorDescription</returns>
[DataMember("errorDescription")]
public str parmErrorDescription(str _value = errorDescription)
{
errorDescription = _value;
return errorDescription;
}
/// <summary>
/// Error Code
/// </summary>
/// <param name = "_value">value</param>
/// <returns>Error Code</returns>
[DataMember("errorCode")]
public str parmErrorCode(str _value = errorCode)
{
errorCode = _value;
return errorCode;
}
/// <summary>
/// error message
/// </summary>
/// <param name = "_value">value</param>
/// <returns>error message</returns>
[DataMember("errorMessage")]
public str parmErrorMessage(str _value = errorMessage)
{
errorMessage = _value;
return errorMessage;
}
}
-------------------------------------------------------------------------------
/// <summary>
/// Response header
/// </summary>
[DataContractAttribute]
[Newtonsoft.Json.JsonObject(IsReference = false)]
[Newtonsoft.Json.JsonArrayAttribute(IsReference = false)]
public class GopResponseHeaderContract
{
private str channelName;
private str senderId;
private str receiverId;
private str countryCode;
private str messageId;
private str dateTime;
private str status;
/// <summary>
/// senderId
/// </summary>
/// <param name = "_value">senderId</param>
/// <returns>senderId</returns>
[DataMember("senderId")]
public str parmSenderId(str _value = senderId)
{
if (!prmIsDefault(_value))
{
senderId = _value;
}
return senderId;
}
/// <summary>
/// channelName
/// </summary>
/// <param name = "_value">channelName</param>
/// <returns>channelName</returns>
[DataMember("channelName")]
public str parmChannelName(str _value = channelName)
{
if (!prmIsDefault(_value))
{
channelName = _value;
}
return channelName;
}
/// <summary>
/// receiverId
/// </summary>
/// <param name = "_value">receiverId</param>
/// <returns>receiverId</returns>
[DataMember("receiverId")]
public str parmReceiverId(str _value = receiverId)
{
if (!prmIsDefault(_value))
{
receiverId = _value;
}
return receiverId;
}
/// <summary>
/// countryCode
/// </summary>
/// <param name = "_value">countryCode</param>
/// <returns>countryCode</returns>
[DataMember("countryCode")]
public str parmCountryCode(str _value = countryCode)
{
if (!prmIsDefault(_value))
{
countryCode = _value;
}
return countryCode;
}
/// <summary>
/// messageId
/// </summary>
/// <param name = "_value">messageId</param>
/// <returns>messageId</returns>
[DataMember("messageId")]
public str parmMessageId(str _value = messageId)
{
if (!prmIsDefault(_value))
{
messageId = _value;
}
return messageId;
}
/// <summary>
/// dateTime
/// </summary>
/// <param name = "_value">dateTime</param>
/// <returns>dateTime</returns>
[DataMember("dateTime")]
public str parmDateTime(str _value = dateTime)
{
if (!prmIsDefault(_value))
{
dateTime = _value;
}
return dateTime;
}
/// <summary>
/// status
/// </summary>
/// <param name = "_value">status</param>
/// <returns>status</returns>
[DataMember("status")]
public str parmStatus(str _value = status)
{
if (!prmIsDefault(_value))
{
status = _value;
}
return status;
}
}
Comments
Post a Comment