/// <summary>
/// Clear through customs.
/// </summary>
/// <param name="commonClearanceData">The common clearance data.</param>
/// <param name="warnings">The warnings.</param>
/// <param name="requestedUrl">The requested URL.</param>
void ICWAccountFactory.ClearThroughCustoms(CommonClearanceData commonClearanceData, List <Warnning> warnings, string requestedUrl)
{
WebsiteModelExtensions.TraceEvent("Starting CWAccountData.ICWAccountFactory.ClearThroughCustoms", 159, TraceSeverity.Verbose, WebsiteModelExtensions.LoggingCategories.CloseAccount);
string _at = "Beginning";
try
{
using (Entities _edc = new Entities(requestedUrl))
{
_at = "ClearanceLookup";
Clearence _Clearance = Element.GetAtIndex <Clearence>(_edc.Clearence, commonClearanceData.ClearenceLookup);
_Clearance.FinishClearThroughCustoms(_edc, (message, eventId, severity) => WebsiteModelExtensions.TraceEvent(message, eventId, severity, WebsiteModelExtensions.LoggingCategories.CloseAccount));
WebsiteModelExtensions.TraceEvent("ICWAccountFactory.ClearThroughCustoms at SubmitChanges", 168, TraceSeverity.Verbose, WebsiteModelExtensions.LoggingCategories.CloseAccount);
_edc.SubmitChanges();
}
}
catch (Exception ex)
{
string _msg = string.Format(Properties.Resources.UnexpectedExceptionMessage, "ICWAccountFactory.CreateCWAccount", _at, ex.Message);
WebsiteModelExtensions.TraceEvent(_msg, 173, TraceSeverity.High, WebsiteModelExtensions.LoggingCategories.CloseAccount);
Warnning _wrn = new Warnning(_msg, true);
warnings.Add(_wrn);
}
WebsiteModelExtensions.TraceEvent("Finishing CWAccountData.ICWAccountFactory.ClearThroughCustoms", 179, TraceSeverity.Verbose, WebsiteModelExtensions.LoggingCategories.CloseAccount);
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountData" /> class.
/// </summary>
/// <param name="edc">The <see cref="Entities" /> object.</param>
/// <param name="clearance">The clearance.</param>
/// <param name="messageType">Type of the customs message.</param>
/// <param name="warnings">The list of warnings.</param>
/// <param name="trace">The trace.</param>
public override void GetAccountData(Entities edc, Clearence clearance, Customs.Account.CommonAccountData.MessageType messageType, List <Warnning> warnings, NamedTraceLogger.TraceAction trace)
{
base.GetAccountData(edc, clearance, messageType, warnings, trace);
Value = clearance.Clearence2SadGoodID.TotalAmountInvoiced.GetValueOrDefault(0);
UnitPrice = Value / NetMass;
AnalizeDutyAndVAT(edc, clearance.Clearence2SadGoodID);
}
/// <summary>
/// Clear through customs according 4071 procedure.
/// </summary>
/// <param name="entities">The entities.</param>
/// <param name="good">The good.</param>
/// <exception cref="InputDataValidationException">Create CW Account Failed;CreateCWAccount</exception>
private static CWClearanceData CWPrepareClearance(Entities entities, SADGood good)
{
Clearence _clearance = GetClearanceIds(entities, good, Settings.GetParameter(entities, SettingsEntry.RequiredDocumentSADTemplateDocumentNamePattern)).First <Clearence>();
_clearance.FinishClearingThroughCustoms(good);
return(new CWClearanceData(_clearance.Id.Value));
}
/// <summary>
/// Creates the IPR account.
/// </summary>
/// <param name="entities">The entities.</param>
/// <param name="clearance">The clearance.</param>
/// <param name="messageType">Type of the _message.</param>
/// <param name="comments">The _comments.</param>
/// <param name="warnings">The list of warnings.</param>
/// <param name="trace">The trace action.</param>
private static void CreateIPRAccount(Entities entities, Clearence clearance, CustomsDocument.DocumentType messageType, out string comments, List <Warnning> warnings, NamedTraceLogger.TraceAction trace)
{
trace("Entering ClearenceHelpers.CreateIPRAccount", 169, TraceSeverity.Verbose);
comments = "IPR account creation error";
string _referenceNumber = String.Empty;
SADDocumentType declaration = clearance.Clearence2SadGoodID.SADDocumentIndex;
_referenceNumber = declaration.ReferenceNumber;
if (WebsiteModel.Linq.IPR.RecordExist(entities, clearance.DocumentNo))
{
string _msg = "IPR record with the same SAD document number: {0} exist";
_msg = String.Format(_msg, clearance.DocumentNo);
trace("Exception at ClearenceHelpers.CreateIPRAccount: " + _msg, 199, TraceSeverity.Verbose);
throw GenericStateMachineEngine.ActionResult.NotValidated(_msg);
}
comments = "Inconsistent or incomplete data to create IPR account";
IPRAccountData _iprdata = new IPRAccountData(clearance.Id.Value);
_iprdata.GetAccountData(entities, clearance, ImportXMLCommon.Convert2MessageType(messageType), warnings, trace);
comments = "Consent lookup filed";
IPRClass _ipr = new IPRClass(entities, _iprdata, clearance, declaration);
entities.IPR.InsertOnSubmit(_ipr);
clearance.SPStatus = true;
trace("ClearenceHelpers.CreateIPRAccount at SubmitChanges", 209, TraceSeverity.Verbose);
entities.SubmitChanges();
_ipr.UpdateTitle();
comments = "IPR account created";
trace("ClearenceHelpers.Create - IPRAccount comments", 213, TraceSeverity.Verbose);
}
private void onCreateMessageTemplates(object sender, EventArgs e)
{
TraceEvent("Entering ClearThroughCustoms.onCreateMessageTemplates", 46, TraceSeverity.Monitorable);
try
{
string _MasterDocumentName = String.Empty;
using (Entities _entities = new Entities(workflowProperties.WebUrl))
{
DisposalRequestLib _Dr = Element.GetAtIndex <DisposalRequestLib>(_entities.DisposalRequestLibrary, workflowProperties.ItemId);
foreach (CustomsWarehouseDisposal _cwdx in _Dr.CustomsWarehouseDisposal(_entities, false))
{
if (_cwdx.CustomsStatus.Value != CustomsStatus.NotStarted)
{
continue;
}
Clearence _newClearance = Clearence.CreataClearence(_entities, "Customs Warehouse Withdraw", _Dr.ClearenceProcedure.Value, TraceEvent);
_cwdx.CWL_CWDisposal2ClearanceID = _newClearance;
_cwdx.CustomsStatus = CustomsStatus.Started;
if (_cwdx.CWL_CWDisposal2CustomsWarehouseID.TobaccoNotAllocated.Value > 0 ||
_cwdx.CWL_CWDisposal2CustomsWarehouseID.CustomsWarehouseDisposal(_entities, false).Where <CustomsWarehouseDisposal>(x => x.CustomsStatus.Value == CustomsStatus.NotStarted).Any <CustomsWarehouseDisposal>())
{
_cwdx.ClearingType = ClearingType.PartialWindingUp;
}
else
{
_cwdx.ClearingType = ClearingType.TotalWindingUp;
_cwdx.TobaccoValue += _cwdx.CWL_CWDisposal2CustomsWarehouseID.Value.Value - _cwdx.CWL_CWDisposal2CustomsWarehouseID.CustomsWarehouseDisposal(_entities, false).Sum <CustomsWarehouseDisposal>(x => x.TobaccoValue.Value);
_cwdx.TobaccoValue = _cwdx.TobaccoValue.Value.RoundValue();
_cwdx.CW_SettledNetMass += _cwdx.CWL_CWDisposal2CustomsWarehouseID.CW_Quantity.Value - _cwdx.CWL_CWDisposal2CustomsWarehouseID.CustomsWarehouseDisposal(_entities, false).Sum <CustomsWarehouseDisposal>(x => x.CW_SettledNetMass.Value);
_cwdx.CW_SettledNetMass = _cwdx.CW_SettledNetMass.Value.RoundValue();
_cwdx.CW_SettledGrossMass += _cwdx.CWL_CWDisposal2CustomsWarehouseID.GrossMass.Value - _cwdx.CWL_CWDisposal2CustomsWarehouseID.CustomsWarehouseDisposal(_entities, false).Sum <CustomsWarehouseDisposal>(x => x.CW_SettledGrossMass.Value);
_cwdx.CW_SettledGrossMass = _cwdx.CW_SettledGrossMass.Value.RoundValue();
}
_MasterDocumentName = _newClearance.SADTemplateDocumentNameFileName(_entities);
SAD _sad = CraeteSAD(_entities, _cwdx, _MasterDocumentName);
TraceEvent(" ClearThroughCustoms.onCreateMessageTemplates at File.CreateXmlFile", 4756, TraceSeverity.Monitorable);
SPFile _newFile = File.CreateXmlFile <SAD>(workflowProperties.Web, _sad, _MasterDocumentName, SADConsignment.IPRSADConsignmentLibraryTitle, SAD.StylesheetNmane);
SADConsignment _sadConsignment = Element.GetAtIndex <SADConsignment>(_entities.SADConsignment, _newFile.Item.ID);
_sadConsignment.Archival = true;
_newClearance.SADConsignmentLibraryIndex = _sadConsignment;
TraceEvent(" ClearThroughCustoms.onCreateMessageTemplates at SubmitChanges", 80, TraceSeverity.Monitorable);
_entities.SubmitChanges();
}
}
logToHistoryListActivity_HistoryOutcome = "Success";
logToHistoryListActivity_HistoryDescription = String.Format("Document {0} created successfully", _MasterDocumentName);
}
catch (Exception _ex)
{
logToHistoryListActivity_HistoryOutcome = "Exception";
logToHistoryListActivity_HistoryDescription = _ex.Message;
TraceEvent(String.Format("Exception {0} at ClearThroughCustoms.onCreateMessageTemplates: {1}; StackTrace: {2}", _ex.GetType().Name, _ex.Message, _ex.StackTrace), 46, TraceSeverity.High);
}
TraceEvent("Finishing ClearThroughCustoms.onCreateMessageTemplates", 98, TraceSeverity.Monitorable);
}
private static void CLNEProcessing(string webUrl, int sadDocumentTypeId, ref string comments, List <Warnning> warnings, NamedTraceLogger.TraceAction trace)
{
trace("Entering ClearenceHelpers.CLNEProcessing", 71, TraceSeverity.Verbose);
List <CWAccountData> _tasksList = new List <CWAccountData>();
using (Entities _entities = new Entities(webUrl))
{
SADDocumentType _sad = Element.GetAtIndex <SADDocumentType>(_entities.SADDocument, sadDocumentTypeId);
IQueryable <Clearence> _clrncs = Clearence.GetClearence(_entities, _sad.ReferenceNumber);
if ((from _cx in _clrncs where _cx.Clearence2SadGoodID == null select _cx).Any <Clearence>())
{
string _error = String.Format("SAD with reference number: {0} must be imported first", _sad.ReferenceNumber);
throw new InputDataValidationException("CLNE message cannot be processed before SAD", "DeclarationProcessing", _error, true);
}
foreach (Clearence _cx in _clrncs)
{
_cx.DocumentNo = _sad.DocumentNumber;
switch (_cx.ClearenceProcedure.Value.RequestedProcedure())
{
case CustomsProcedureCodes.FreeCirculation:
_cx.FinishClearingThroughCustoms(_entities, trace);
break;
case CustomsProcedureCodes.InwardProcessing:
CreateIPRAccount(_entities, _cx, CustomsDocument.DocumentType.SAD, out comments, warnings, trace);
break;
case CustomsProcedureCodes.CustomsWarehousingProcedure:
throw new NotImplementedException("CLNEProcessing - CustomsWarehousingProcedure"); //TODO http://casas:11227/sites/awt/Lists/RequirementsList/_cts/Requirements/displayifs.aspx?List=e1cf335a
//comments = "CW account creation error";
//CWAccountData _accountData = new CWAccountData(_cx.Id.Value);
//_accountData.GetAccountData(_entities, _cx, ImportXMLCommon.Convert2MessageType(CustomsDocument.DocumentType.SAD), progressChange);
//CreateCWAccount(_accountData, webUrl, out comments);
//break;
case CustomsProcedureCodes.ReExport:
case CustomsProcedureCodes.NoProcedure:
default:
throw new IPRDataConsistencyException("CLNEProcessing", "Unexpected procedure code for CLNE message", null, c_wrongProcedure);
}
}
_entities.SubmitChanges();
}
trace("ClearenceHelpers.CLNEProcessing at CreateCWAccount", 109, TraceSeverity.Verbose);
foreach (CWAccountData _accountData in _tasksList)
{
CreateCWAccount(_accountData, webUrl, out comments);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AccountData" /> class.
/// </summary>
/// <param name="edc">The <see cref="Entities" /> object.</param>
/// <param name="clearance">The clearance.</param>
/// <param name="messageType">Type of the customs message.</param>
/// <param name="warnings">The list of warnings.</param>
/// <param name="trace">The trace.</param>
public virtual void GetAccountData(Entities edc, Clearence clearance, MessageType messageType, List <Warnning> warnings, NamedTraceLogger.TraceAction trace)
{
trace("Entering AccountData.GetAccountData", 50, TraceSeverity.Verbose);
DocumentNo = clearance.DocumentNo;
DateTime _customsDebtDate = clearance.Clearence2SadGoodID.SADDocumentIndex.CustomsDebtDate.Value;
this.CustomsDebtDate = _customsDebtDate;
AnalizeGood(edc, clearance.Clearence2SadGoodID, messageType);
IEnumerable <SADRequiredDocuments> _rdoc = clearance.Clearence2SadGoodID.SADRequiredDocuments(edc);
this.Invoice = (from _dx in _rdoc
let CustomsProcedureCode = _dx.Code.ToUpper()
where CustomsProcedureCode.Contains("N380") || CustomsProcedureCode.Contains("N935")
select new { Number = _dx.Number }
).First().Number;
FindConsentRecord(edc, _rdoc, _customsDebtDate, warnings, trace);
AnalyzeGoodsDescription(edc, clearance.Clearence2SadGoodID.GoodsDescription); //TODO to IPR
PCNTariffCodeLookup = PCNCode.AddOrGet(edc, clearance.Clearence2SadGoodID.PCNTariffCode, TobaccoName).Id.Value;
}
private static List <Clearence> GetClearanceIds(Entities entities, SADGood good, string pattern)
{
List <Clearence> _ret = new List <Clearence>();
foreach (SADRequiredDocuments _rdx in good.SADRequiredDocuments(entities))
{
if (_rdx.Code != XMLResources.RequiredDocumentConsignmentCode)
{
continue;
}
int?_cleranceInt = XMLResources.GetRequiredDocumentFinishedGoodExportConsignmentNumber(_rdx.Number, pattern);
if (!_cleranceInt.HasValue)
{
continue;
}
if (_cleranceInt.HasValue)
{
Clearence _clearance = Element.GetAtIndex <Clearence>(entities.Clearence, _cleranceInt.Value);
_ret.Add(_clearance);
}
else
{
string _template = "Cannot find clearance for the required document code={0} for customs document = {1}/ref={2}";
throw new InputDataValidationException(
String.Format(_template, _rdx.Number, good.SADDocumentIndex.DocumentNumber, good.SADDocumentIndex.ReferenceNumber),
"SAD Required Documents",
"clear through customs fatal error", true);
}
}// foreach
if (_ret.Count == 0)
{
string _template = "Cannot find required document code={0} for customs document = {1}/ref={2}";
throw new InputDataValidationException(
String.Format(_template, XMLResources.RequiredDocumentConsignmentCode, good.SADDocumentIndex.DocumentNumber, good.SADDocumentIndex.ReferenceNumber),
"SAD Required Documents",
"clear through customs fatal error", true);
}
return(_ret);
}
private GenericStateMachineEngine.ActionResult Export()
{
TraceEvent("Entering ExportWebPartUserControl.Export", 578, TraceSeverity.Monitorable);
foreach (InvoiceContent item in m_ControlState.Invoice.InvoiceContent(m_DataContextManagement.DataContext))
{
//TODO ExportIsPossible - improve for many invoice content with the same FG batch groups by batch must be checked against possible export
string _checkResult = item.ExportIsPossible(m_DataContextManagement.DataContext, item.Quantity);
if (_checkResult.IsNullOrEmpty())
{
TraceEvent(String.Format("Checked Item {0}", item.Title), 585, TraceSeverity.Verbose);
continue;
}
Controls.Add(ControlExtensions.CreateMessage(_checkResult));
m_ControlState.InvoiceContent = item;
string _ms = "CannotProceedWithExportBecauseTheInvoiceItemContainsErrors".GetLocalizedString();
_ms = String.Format(_ms, item.Title);
TraceEvent(_ms, 592, TraceSeverity.Verbose);
return(GenericStateMachineEngine.ActionResult.NotValidated(_ms));
}
m_ControlState.Invoice.InvoiceLibraryStatus = true;
Clearence _newClearance = Clearence.CreateClearance(m_DataContextManagement.DataContext, "FinishedGoodsExport", ClearenceProcedure._3151, (x, y, z) => TraceEvent(x, y, z));
string _masterDocumentName = _newClearance.FinishedGoodsExportFormFileName(m_DataContextManagement.DataContext);
TraceEvent(String.Format("ExportWebPartUserControl.Export - generated document name: {0}", _masterDocumentName), 578, TraceSeverity.Verbose);
CigaretteExportFormCollection _cefc = FinishedGoodsFormFactory.GetFormContent
(m_DataContextManagement.DataContext, m_ControlState.Invoice, _newClearance, _masterDocumentName, _newClearance.SADDocumentNumber, (x, y, z) => TraceEvent(x, y, z));
TraceEvent(String.Format("ExportWebPartUserControl.Export - at SPDocumentFactory.Prepare", _masterDocumentName), 578, TraceSeverity.Verbose);
int _sadConsignmentIdentifier = SPDocumentFactory.Prepare(SPContext.Current.Web, _cefc, _masterDocumentName, (x, y, z) => TraceEvent(x, y, z));
SADConsignment _sadConsignment = Element.GetAtIndex <SADConsignment>(m_DataContextManagement.DataContext.SADConsignment, _sadConsignmentIdentifier);
_newClearance.SADConsignmentLibraryIndex = _sadConsignment;
TraceEvent("ExportWebPartUserControl.Export at SubmitChanges", 605, TraceSeverity.Verbose);
m_DataContextManagement.DataContext.SubmitChanges();
TraceEvent("Finished ExportWebPartUserControl.Export", 607, TraceSeverity.Verbose);
return(GenericStateMachineEngine.ActionResult.Success);
}
private void Create(NamedTraceLogger.TraceAction trace)
{
CurrentClearance = Clearence.CreateClearance(m_DataContextManagement.DataContext, m_SelectGroupRadioButtonList.SelectedValue, SelectedClearenceProcedure, trace);
Update();
Response.Redirect(Request.RawUrl);
}
private static void SADPZCProcessing(string webUrl, CustomsDocument.DocumentType messageType, int sadDocumentTypeId, ref string comments, List <Warnning> warnings, NamedTraceLogger.TraceAction trace)
{
trace("Entering ClearenceHelpers.SADPZCProcessing", 71, TraceSeverity.Verbose);
List <CommonClearanceData> _tasksList = new List <CommonClearanceData>();
using (Entities entities = new Entities(webUrl))
{
SADDocumentType sad = Element.GetAtIndex <SADDocumentType>(entities.SADDocument, sadDocumentTypeId);
foreach (SADGood _sgx in sad.SADGood(entities))
{
switch (_sgx.SPProcedure.RequestedProcedure())
{
case CustomsProcedureCodes.FreeCirculation:
if (messageType == CustomsDocument.DocumentType.SAD)
{
comments = "Document added";
continue;
}
if (_sgx.SPProcedure.PreviousProcedure() == CustomsProcedureCodes.CustomsWarehousingProcedure)
{
_tasksList.Add(CWPrepareClearance(entities, _sgx)); //Procedure 4071
}
else if (_sgx.SPProcedure.PreviousProcedure() == CustomsProcedureCodes.InwardProcessing)
{
IPRClearThroughCustoms(entities, _sgx, trace); //Procedure 4051
}
else
{
string _msg = string.Format("Unexpected previous procedure code {1} for the {0} message", messageType, _sgx.SPProcedure.PreviousProcedure());
trace("IPRDataConsistencyException at ClearenceHelpers.SADPZCProcessing: ", 140, TraceSeverity.Verbose);
throw new IPRDataConsistencyException("SADPZCProcessing.FreeCirculation", _msg, null, c_wrongProcedure);
}
break;
case CustomsProcedureCodes.InwardProcessing:
{
if (messageType == CustomsDocument.DocumentType.SAD)
{
comments = "Document added";
continue;
}
if (_sgx.SPProcedure.PreviousProcedure() == CustomsProcedureCodes.CustomsWarehousingProcedure)
{
_tasksList.Add(CWPrepareClearance(entities, _sgx)); //Procedure 5171
}
// Procedure 5100 or 5171
Clearence _newClearance = Clearence.CreataClearance(entities, "InwardProcessing", ClearenceProcedure._5171, _sgx);
CreateIPRAccount(entities, _newClearance, CustomsDocument.DocumentType.PZC, out comments, warnings, trace);
break;
}
case CustomsProcedureCodes.CustomsWarehousingProcedure:
Clearence _newWarehousinClearance = Clearence.CreataClearance(entities, "CustomsWarehousingProcedure", ClearenceProcedure._7100, _sgx);
if (messageType == CustomsDocument.DocumentType.PZC)
{
comments = "CW account creation error";
CWAccountData _accountData = new CWAccountData(_newWarehousinClearance.Id.Value);
_accountData.GetAccountData(entities, _newWarehousinClearance, ImportXMLCommon.Convert2MessageType(CustomsDocument.DocumentType.SAD), warnings, trace);
_tasksList.Add(_accountData);
}
else
{
comments = "Document added";
}
break;
case CustomsProcedureCodes.NoProcedure:
case CustomsProcedureCodes.ReExport:
default:
throw new IPRDataConsistencyException("SADPZCProcessing.RequestedProcedure", string.Format("Unexpected procedure code for the {0} message", messageType), null, c_wrongProcedure);
} //switch ( _sgx.Procedure.RequestedProcedure() )
} //foreach ( SADGood _sgx in sad.SADGood )
entities.SubmitChanges();
} //using ( Entities entities
foreach (CommonClearanceData _accountData in _tasksList)
{
if (_accountData is CWAccountData)
{
CreateCWAccount((CWAccountData)_accountData, webUrl, out comments);
}
else if (_accountData is CWClearanceData)
{
CWClearThroughCustoms((CWClearanceData)_accountData, webUrl, out comments);
}
}
}
internal static CigaretteExportFormCollection GetFormContent(Entities entities, InvoiceLib invoice, Clearence clearance, string documentName, int sadConsignmentNumber, NamedTraceLogger.TraceAction trace)
{
trace("Entering FinishedGoodsFormFactory.GetFormContent", 40, TraceSeverity.Verbose);
int _position = 1;
List <CigaretteExportForm> _consignment = new List <CigaretteExportForm>();
invoice.ClearenceIndex = clearance;
invoice.InvoiceLibraryReadOnly = true;
foreach (InvoiceContent item in invoice.InvoiceContent(entities))
{
ExportInvoiceEntry(entities, item, _consignment, documentName, ref _position, sadConsignmentNumber, trace);
}
trace("FinishedGoodsFormFactory.GetFormContent - finished processing invoice items", 40, TraceSeverity.Verbose);
return(GetCigaretteExportFormCollection(_consignment, documentName, invoice.BillDoc));
}
