/// <summary>
        /// Creates the CW account.
        /// </summary>
        /// <param name="_accountData">The _account data.</param>
        /// <param name="requestUrl">The request URL.</param>
        /// <param name="comments">The comments.</param>
        /// <exception cref="InputDataValidationException">Create CW Account Failed;CreateCWAccount</exception>
        /// <exception cref="IPRDataConsistencyException">IPR account creation error</exception>
        private static void CreateCWAccount(CWAccountData _accountData, string requestUrl, out string comments)
        {
            List <Warnning> _lw = new List <Warnning>();

            _accountData.CallService(requestUrl, _lw);
            if (_lw.Count == 0)
            {
                comments = "CW account created";
                return;
            }
            ErrorsList _el = new ErrorsList();

            _el.AddRange(_lw);
            throw new InputDataValidationException("Create CW Account Failed", "CreateCWAccount", _el);
        }
        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);
                }
            }
        }