public IHttpActionResult Post(NameAndAddressParameter parameter)
        {
            try
            {
                // Use indexed DI resoloution
                IGetRequestProcess nameAndAddress = _strategyProcesses[GetRequestProcessImplementations.NameAndAddress];

                //NameAndAddressStrategy nameAndAddress = new NameAndAddressStrategy(parameter, _mailingHistoryService,
                //    _mciRequestService, _clientScopeService, _logger, _permissionsService, _membershipService,
                //    _customerMatchService, _customerDetailsService, _travelSummaryService);
                parameter.AccessControl =
                    _clientScopeService.VerifyUserHasAccessToGroupCode(parameter.AccessControl,
                                                                       Scope.CUSTOMER_RETRIEVE_NAMEADDR);
                object output = nameAndAddress.Execute(parameter);
                return(Ok(output));
            }
            catch (Exception exception)
            {
                if (_logParameterValue)
                {
                    _logger.Error($"PermissionGet: ErrorTag: {ErrorTagProvider.ErrorTagDatabase} --  {exception.Message}");

                    _logger.Error(
                        $"Parameters PermissionLoad:- Name=FirstName={parameter.NameAndAddress.FirstName}, LastName={parameter.NameAndAddress.Surname}, Dob={parameter.NameAndAddress.Dob}, " +
                        $" Address=AddresLine1={ parameter.NameAndAddress.Address.Address1 ?? ""}, AddressLine2={parameter.NameAndAddress.Address.Address2 ?? ""}, AddressLine3={parameter.NameAndAddress.Address.Address3 ?? ""}, " +
                        $" AddressLine4={parameter.NameAndAddress.Address.Address4 ?? ""}, PostCode={parameter.NameAndAddress.Address.Postcode ?? ""}");
                }
                //return Ok(exception);
                return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message)));
            }
        }
        /// <summary>
        /// Refactored from MembershipProcess.GetMembershipOptionsData()
        /// </summary>
        /// <param name="nameAndAddressParameter"></param>
        /// <param name="customerId"></param>
        /// <returns></returns>
        public object Process(NameAndAddressParameter nameAndAddressParameter, int?customerId)
        {
            var mOptionsOutput = new MembershipOptionsDataOutputV2();

            try
            {
                mOptionsOutput.MembershipOptionsData.MembershipStatusData    = _membershipDataAccess.GetMembershipStatus();
                mOptionsOutput.MembershipOptionsData.ActivationDeclineReason = _membershipDataAccess.GetActivationDeclineReason();
                mOptionsOutput.MembershipOptionsData.OverrideReason          = _membershipDataAccess.GetOverrideReason();
                mOptionsOutput.MembershipOptionsData.FulfilmentOverride      = _membershipDataAccess.GetFulfilmentOverride();
                mOptionsOutput.MembershipOptionsData.ActivationSource        = _membershipDataAccess.GetActivationSource();
                mOptionsOutput.MembershipOptionsData.MembershipStatusReason  = _membershipDataAccess.GetMembershipStatusReason();

                // GITCS-9 : Cancellation reasons only on V2
                mOptionsOutput.MembershipOptionsData.MembershipCancellationReason =
                    _membershipDataAccess.GetMembershipCancelReason();


                return(mOptionsOutput);
            }
            catch (Exception ex)
            {
                _logger.Error("GetMembershipOptionsData : ErrorTag: " + ErrorTagProvider.ErrorTagDatabase + " -- " + ex.Message, ex);
                throw new Exception(ex.Message);
            }
        }
        public IHttpActionResult PostV2(NameAndAddressParameter parameter)
        {
            try
            {
                // Use indexed DI resoloution for V2 strategy
                IGetRequestProcess nameAndAddress = _strategyProcesses[GetRequestProcessImplementations.NameAndAddressV2];

                parameter.AccessControl =
                    _clientScopeService.VerifyUserHasAccessToGroupCode(parameter.AccessControl,
                                                                       Scope.CUSTOMER_RETRIEVE_NAMEADDR);
                object output = nameAndAddress.Execute(parameter);
                return(Ok(output));
            }
            catch (Exception exception)
            {
                if (_logParameterValue)
                {
                    _logger.Error($"NameAndAddress: ErrorTag: {ErrorTagProvider.ErrorTagDatabase} --  {exception.Message}");

                    _logger.Error(
                        $"Parameters NameAndAddress:- Name=FirstName={parameter.NameAndAddress.FirstName}, LastName={parameter.NameAndAddress.Surname}, Dob={parameter.NameAndAddress.Dob}, " +
                        $" Address=AddresLine1={ parameter.NameAndAddress.Address.Address1 ?? ""}, AddressLine2={parameter.NameAndAddress.Address.Address2 ?? ""}, AddressLine3={parameter.NameAndAddress.Address.Address3 ?? ""}, " +
                        $" AddressLine4={parameter.NameAndAddress.Address.Address4 ?? ""}, PostCode={parameter.NameAndAddress.Address.Postcode ?? ""}");
                }
                //return Ok(exception);
                return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message)));
            }
        }
 public CustomerMatchProcess(NameAndAddressParameter nameAndAddress, ICustomerMatchService customerMatchService, ITravelSummaryService travelSummaryService, ILog logger)
 {
     _nameAndAddress       = nameAndAddress;
     _travelSummaryService = travelSummaryService;
     _customerMatchService = customerMatchService;
     _logger            = logger;
     _logParameterValue = Convert.ToBoolean(ConfigurationManager.AppSettings["EnableObjectDump"]);
 }
예제 #5
0
 public ProcessPermission(KeyValueParameter keyValueParameter, IPermissionService permissionService, IMciRequestService mciRequestService, ILog logger, NameAndAddressParameter nameAndAddress)
 {
     _permissionService = permissionService;
     _logger            = logger;
     _nameAndAddress    = nameAndAddress;
     _mciRequestService = mciRequestService;
     _keyValueParameter = keyValueParameter;
     _logParameterValue = Convert.ToBoolean(ConfigurationManager.AppSettings["EnableObjectDump"]);
 }
예제 #6
0
 public MailingHistoryProcess(NameAndAddressParameter nameAndAddress, IMailingHistoryService mailingHistoryService, IMciRequestService mciRequestService, IClientScopeService clientScopeService, ILog logger, KeyValueParameter keyValue = null)
 {
     _nameAndAddress        = nameAndAddress;
     _keyValue              = keyValue;
     _mailingHistoryService = mailingHistoryService;
     _mciRequestService     = mciRequestService;
     _clientScopeService    = clientScopeService;
     _logger = logger;
 }
예제 #7
0
        /// <summary>
        /// Fetch Membership  details for customer
        /// Refactored logic from MembershipProcess.GetMembershipFromNameAndAddress()
        /// </summary>
        /// <param name="nameAndAddressParameter">NameAndAddress to identify customer</param>
        /// <param name="customerId">Customer Id used in preference to the above if passed</param>
        /// <returns></returns>
        public object Process(NameAndAddressParameter nameAndAddressParameter, int?customerId)
        {
            if (nameAndAddressParameter.AccessControl.ModuleAccess.Find(x => x.HasAccess && x.Key == GroupCode.MEMB) == null)
            {
                NoAccessToMembership message = new NoAccessToMembership();
                message.Message = "You dont' have access for Membership data.";
                return(message);
            }

            var membershipOutputData = new MembershipOutput();

            try
            {
                // Use any Customer Id passed else use NameAddr lookup
                var pkey = customerId ?? _mciRequestDataAccess.GetPersistantKey(nameAndAddressParameter.NameAndAddress);

                if (pkey > 0)
                {
                    _logger.Info("Pkey Found " + pkey);
                    nameAndAddressParameter.ReturnMe.Membership.CustomerId = pkey.Value.ToString();
                    var membershipDetails = _membershipDataAccess.GetMembershipDetails(pkey.Value.ToString());

                    membershipOutputData.MembershipData = membershipDetails;

                    if (string.IsNullOrEmpty(membershipOutputData.MembershipData.ActivationId) &&
                        string.IsNullOrEmpty(membershipOutputData.MembershipData.EncryptedActivationId))
                    {
                        IDictionary <string, string> output =
                            _membershipDataAccess.CreateMembership(nameAndAddressParameter?.ReturnMe?.Membership);

                        membershipOutputData.MembershipData.ActivationId = output["ActivationId"];
                        membershipOutputData.MembershipData =
                            _membershipDataAccess.GetMembershipDetails(membershipOutputData.MembershipData.ActivationId);
                    }
                }
                else
                {
                    return(HttpStatusCode.NotFound);
                }
            }
            catch (Exception ex)
            {
                _logger.Error("GetMembershipFromNameAndAddress : ErrorTag: " + ErrorTagProvider.ErrorTagDatabase + " -- " + ex.Message, ex);

                if (_logParameterValues)
                {
                    _logger.Error(
                        $"Parameters GetMembershipFromNameAndAddress:- Name=FirstName={nameAndAddressParameter.NameAndAddress.FirstName}, LastName={nameAndAddressParameter.NameAndAddress.Surname}, Dob={nameAndAddressParameter.NameAndAddress.Dob}, " +
                        $"Address=AddresLine1={nameAndAddressParameter.NameAndAddress.Address.Address1}, AddressLine2={nameAndAddressParameter.NameAndAddress.Address.Address2}, AddressLine3={nameAndAddressParameter.NameAndAddress.Address.Address3}, " +
                        $"AddressLine4={nameAndAddressParameter.NameAndAddress.Address.Address4}, PostCode={nameAndAddressParameter.NameAndAddress.Address.Postcode}");
                }

                throw new Exception(ex.Message);
            }
            return(membershipOutputData);
        }
 public MembershipProcess(KeyValueParameter keyValue, IMembershipService membershipService,
                          IMciRequestService mciRequestService, ILog logger, NameAndAddressParameter nameAndAddress = null)
 {
     _keyValue          = keyValue;
     _nameAndAddress    = nameAndAddress;
     _mciRequestService = mciRequestService;
     _membershipService = membershipService;
     _logger            = logger;
     _logParameterValue = Convert.ToBoolean(ConfigurationManager.AppSettings["EnableObjectDump"]);
 }
예제 #9
0
        /// <summary>
        /// Generate a custom MembershipPermissionFlags resposnse
        /// NB : Logic refactored from ProcessPermission.ProcessPermissionFromKeyValue() & MembershipProcess.ProcessMembershipWithKeyValue()
        /// </summary>
        /// <returns></returns>
        public object Process(KeyValueParameter keyValueParameter)
        {
            _keyValueParameter       = keyValueParameter;
            _nameAndAddressParameter = BuildWorkingNameAndAddressParameter(keyValueParameter);
            // Dummy NameAndAddress instance - Service and DataAccess classes expect one ...


            MembershipFlags membershipFlags = null;

            try
            {
                // If we have A CPC Key , use the CPC method to get the customer_id from the PermissionsId key value
                int pKey = string.Compare(keyValueParameter.KeyValue.Key, "CPCK", StringComparison.CurrentCultureIgnoreCase) == 0
                    ? GetCustomerIdFromPermissionId(Convert.ToInt64(keyValueParameter.KeyValue.Value))
                    : GetCustomerIdFromKeyValue();
                // Else use MCI customer Index lookup

                if (pKey > 0)
                {
                    try
                    {
                        // Cell services to retrieve data
                        PermissionFull    permissionsFull   = GetPermissionsFull(pKey);
                        MembershipDetails membershipDetails = GetMembershipDetails(pKey);

                        // Build our cuistomised response class...
                        membershipFlags = BuildMembershipPermissionFlags(
                            permissionsFull,
                            membershipDetails
                            );
                    }
                    catch (Exception ex)
                    {
                        _logger.Error("KeyValueMembershipFlagsReadStrategyPart.Process() :" + ex.Message, ex);
                        if (_logParameterValues)
                        {
                            _logger.Error($"KeyValueMembershipFlagsReadStrategyPart.Process() :- Key={keyValueParameter.KeyValue.Key}, Value={keyValueParameter.KeyValue.Value}");
                        }
                        throw new Exception(ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error("ProcessPermission Key and Value Execute :" + ex.Message, ex);
                if (_logParameterValues)
                {
                    _logger.Error($"Parameters ProcessPermissionFromKeyValue:- Key={keyValueParameter.KeyValue.Key}, Value={keyValueParameter.KeyValue.Value}");
                }

                throw new Exception(ex.Message);
            }
            return(membershipFlags);
        }
예제 #10
0
        private NameAndAddressParameter BuildWorkingNameAndAddressParameter(KeyValueParameter keyValueParameter)
        {
            NameAndAddressParameter tempNad = new NameAndAddressParameter();

            tempNad.AccessControl          = keyValueParameter.AccessControl;
            tempNad.ResponseRequestedItems = keyValueParameter.ResponseRequestedItems;
            tempNad.ReturnMe       = keyValueParameter.ReturnMe;
            tempNad.NameAndAddress = new WebApiServices.Models.NameAndAddress();

            return(tempNad);
        }
        public IHttpActionResult MembershipLoad(MembershipDataInputModel membership)
        {
            try
            {
                //pass the data to the service to insert into the database
                string message = string.Empty;

                var mappedModel = Mapper.Map <MembershipDataInputModel, MembershipDataInput>(membership);

                NameAndAddressParameter nameAndAddress = new NameAndAddressParameter
                {
                    NameAndAddress = membership.CustNameAndAddress
                };
                var membershipProcess = new MembershipProcess(null, _membershipService, _mciRequestService, _logger, nameAndAddress);

                List <MembershipOutput> result = new List <MembershipOutput>();
                result.Add(new MembershipOutput()
                {
                    MembershipData = membershipProcess.UpdateMembershipData(mappedModel)
                });
                return(Ok(result));
            }
            catch (Exception exception)
            {
                if (_logParameterValue)
                {
                    _logger.Error($"MembershipLoad: ErrorTag: {ErrorTagProvider.ErrorTagDatabase} --  {exception.Message}");

                    _logger.Error(
                        $"Parameters MembershipLoad:- Name=FirstName={membership.CustNameAndAddress.FirstName}, LastName={membership.CustNameAndAddress.Surname}, Dob={membership.CustNameAndAddress.Dob}, " +
                        $" Address=AddresLine1={ membership.CustNameAndAddress.Address.Address1 ?? ""}, AddressLine2={membership.CustNameAndAddress.Address.Address2 ?? ""}, AddressLine3={membership.CustNameAndAddress.Address.Address3 ?? ""}, " +
                        $" AddressLine4={membership.CustNameAndAddress.Address.Address4 ?? ""}, PostCode={membership.CustNameAndAddress.Address.Postcode ?? ""}");
                }
                return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message)));
            }
        }
        public object ProcessForNameAndAddress(NameAndAddressParameter nameAndAddressParameter, KeyValueParameter keyValueParameter = null)
        {
            List <string> emptyList = new List <string>();

            if (nameAndAddressParameter.ReturnMe.CustomerKeys.SequenceEqual(emptyList))
            {
                NoAccessToCusotmerKeys message = new NoAccessToCusotmerKeys();
                message.Message = null;
                return(message);
            }
            else if (nameAndAddressParameter.AccessControl.CustomerKeyAccess.Find(x => x.HasAccess) == null)
            {
                NoAccessToCusotmerKeys message = new NoAccessToCusotmerKeys();
                message.Message = "You dont' have access CustomerKeys data.";
                return(message);
            }

            if (nameAndAddressParameter == null)
            {
                throw new ArgumentException("NameAndAddress cannot be null.");
            }

            object       customerIndexList = new object();
            CustomerKeys keys = new CustomerKeys();

            try
            {
                var pkey = _mciRequestService.GetPersistantKey(nameAndAddressParameter.NameAndAddress);

                if (pkey == null || !pkey.HasValue)
                {
                    keys.Keys.HasPartialResult = false;
                    keys.Keys         = null;
                    customerIndexList = keys;
                }
                else
                {
                    if (keyValueParameter == null)
                    {
                        ReturnMeForKeyValuePair returnme = new ReturnMeForKeyValuePair();
                        returnme.CustomerKeys   = nameAndAddressParameter.ReturnMe.CustomerKeys;
                        returnme.MailingHistory = nameAndAddressParameter.ReturnMe.MailingHistory;
                        returnme.Membership     = nameAndAddressParameter.ReturnMe.Membership;
                        returnme.Permissions    = nameAndAddressParameter.ReturnMe.Permissions;
                        keyValueParameter       = new KeyValueParameter {
                            AccessControl = nameAndAddressParameter.AccessControl, ReturnMe = returnme
                        };
                    }
                    keyValueParameter.KeyValue.Key   = "PKEY";
                    keyValueParameter.KeyValue.Value = pkey.Value.ToString();

                    // AE : Feb 18
                    // Call to New self instance ! Replace with direct call to target ley value Process() method
                    // var customerKeyProcess = new CustomerKeyProcess(keyValueParameter, _mciRequestService,
                    //     _clientScopeService, _logger);
                    // customerIndexList = customerKeyProcess.Process();
                    customerIndexList = Process(keyValueParameter);
                }
            }
            catch (Exception ex)
            {
                _logger.Error("NameAndAddressStrategy Execute (CustomerKeys) " + "ErrorTag: " + ErrorTagProvider.ErrorTag + " -- " + ex.Message, ex);
                throw new Exception(ex.Message);
            }

            return(customerIndexList);
        }
예제 #13
0
 public object[] Execute(NameAndAddressParameter nameAndAddress)
 {
     throw new NotSupportedException("Name and address calls not supported on KeyValuePairStrategy");
 }
예제 #14
0
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            string body  = actionContext.Request.Content.ReadAsStringAsync().Result;
            var    model = new NameAndAddressParameter();
            var    a     = JsonConvert.DeserializeObject <NameAndAddressParameter>(body);

            JsonConvert.PopulateObject(body, model);

            if ((model.ReturnMe.Permissions != null && model.ReturnMe.Permissions.Required))
            {
                model.ResponseRequestedItems.Add("permissions");
                model.NameAndAddress.Address.Address1  = BuildAddress1(model.NameAndAddress);
                model.NameAndAddress.Address.Address2  = model.NameAndAddress.Address.Address2 ?? (model.NameAndAddress.CustomerAddress.City ?? "");
                model.NameAndAddress.Address.Address3  = model.NameAndAddress.Address.Address3 ?? (model.NameAndAddress.CustomerAddress.County ?? "");
                model.NameAndAddress.Address.Address4  = model.NameAndAddress.Address.Address4 ?? (model.NameAndAddress.CustomerAddress.Country ?? "");
                model.NameAndAddress.Address.Postcode  = model.NameAndAddress.Address.Postcode ?? model.NameAndAddress.CustomerAddress.Postcode;
                model.NameAndAddress.Address.MatchType = MatchType.NAME_AND_ADDRESS.ToLowerString();
                model.NameAndAddress.MatchType         = MatchType.NAME_AND_ADDRESS.ToLowerString();
                model.ReturnMe.Permissions.MatchType   = MatchType.NAME_AND_ADDRESS.ToLowerString();
            }
            if ((model.ReturnMe.Membership != null && model.ReturnMe.Membership.Required))
            {
                model.ResponseRequestedItems.Add("membership");
            }
            if (model.ReturnMe.MailingHistory != null)
            {
                model.ResponseRequestedItems.Add("mailinghistory");
                model.NameAndAddress.MatchType          = MatchType.NAME_AND_ADDRESS.ToLowerString();
                model.ReturnMe.MailingHistory.MatchType = MatchType.NAME_AND_ADDRESS.ToLowerString();
            }
            List <string> emptyList = new List <string>();

            if (model.ReturnMe.CustomerKeys != null && model.ReturnMe.CustomerKeys.SequenceEqual(emptyList) || model.ReturnMe.CustomerKeys?.Count > 0)
            {
                model.ResponseRequestedItems.Add("customerkeys");
                model.AccessControl.CustomerKeyAccess = model.ReturnMe.CustomerKeys.ToCustomerKeyGroupCodeEnum();
            }
            if (model.ReturnMe.CustomerDetail != null && model.ReturnMe.CustomerDetail.Required)
            {
                model.ResponseRequestedItems.Add("customerdetail");
            }
            if (model.ReturnMe.TravelSummary != null && model.ReturnMe.TravelSummary.Required)
            {
                model.ResponseRequestedItems.Add("travelsummary");
            }
            // if (model.ReturnMe.CustomerMatch?.MatchType != null)
            if (model.ReturnMe.CustomerMatch != null)
            {
                //matchtype we need in all levels models to validate purpose, hence we hae MatchPrperty in child object of NameAndAddressParameter model
                model.ResponseRequestedItems.Add("customermatch");
                //
                // GITCS-3 : We now accept "null" match type value - must map to DEFAULT MatchType enum value for new default matching rules
                model.ReturnMe.CustomerMatch.MatchType =
                    model.ReturnMe.CustomerMatch.MatchType?.ToLower().Trim() == "null"
                        ? MatchType.DEFAULT.ToString().ToLower()
                        : model.ReturnMe.CustomerMatch.MatchType?.ToLower().Trim()
                ;
                // Synch the other 2 match types
                model.NameAndAddress.MatchType         = model.ReturnMe.CustomerMatch.MatchType;
                model.NameAndAddress.Address.MatchType = model.ReturnMe.CustomerMatch.MatchType;
                //
                // model.NameAndAddress.MatchType = model.ReturnMe.CustomerMatch.MatchType.ToLower().Trim();
                // model.NameAndAddress.Address.MatchType = model.ReturnMe.CustomerMatch.MatchType.ToLower().Trim();
            }


            model.AccessControl.ModuleAccess = model.ResponseRequestedItems.ToGroupCodeEnum();


            var validator = new NameAndAddressParameterValidator();
            var result    = validator.Validate(model);

            foreach (var e in result.Errors)
            {
                bindingContext.ModelState.AddModelError(e.PropertyName, e.ErrorMessage);
            }

            bindingContext.Model = model;

            return(true);
        }
        public object[] Execute(KeyValueParameter keyValue)
        {
            int processedObject = 0;

            _keyValue = keyValue;

            object[] output = new object[_keyValue.ResponseRequestedItems.Count];
            try
            {
                //if (_keyValue.ReturnMe.CustomerKeys != null)
                //{
                //    var customerKeyProcess = new CustomerKeyProcess(_keyValue, _mciRequestService,
                //        _clientScopeService, _logger);
                //    output[_processedObject] = customerKeyProcess.Process();
                //    _processedObject++;
                //}

                //if (_keyValue.ReturnMe.MailingHistory != null)
                //{
                //    MailingHistoryProcess mailingHistoryProcess = new MailingHistoryProcess(
                //        _nameAndAddress, _mailingHistoryService, _mciRequestService, _clientScopeService,
                //        _logger, _keyValue);
                //    output[_processedObject] = mailingHistoryProcess.ProcessForKeyValue();
                //    _processedObject++;
                //}

                if (_keyValue.ReturnMe.Permissions != null && _keyValue.ReturnMe.Permissions.Required)
                {
                    // we make some temporary parameters to pass so that we can create an address to construct
                    // the ProcessPermission() object

                    //KeyValueParameter tempKVP = new KeyValueParameter();
                    //tempKVP.KeyValue = _keyValue.KeyValue;
                    //tempKVP.AccessControl = new WebApiServices.Models.Security.AccessControl();
                    //tempKVP.AccessControl.CustomerKeyAccess.Add(new WebApiServices.Models.Security.CustomerKeyAccess() { HasAccess = true, Key = WebApiServices.Models.GroupCode.GCUST });
                    //tempKVP.AccessControl.ModuleAccess.Add(new WebApiServices.Models.Security.ModuleAccess() { HasAccess = true, Key = WebApiServices.Models.GroupCode.GCUST });
                    //tempKVP.ReturnMe.CustomerDetails.AddressType = AddressType.Correspondence;


                    //var customerDetails = new CustomerDetailsProcess(tempKVP, _customerDetailsService, _logger);
                    //WebApiServices.Models.Customer.CustomerInfoDetails details = customerDetails.Process() as WebApiServices.Models.Customer.CustomerInfoDetails;

                    NameAndAddressParameter tempNad = new NameAndAddressParameter();

                    tempNad.AccessControl          = _keyValue.AccessControl;
                    tempNad.ResponseRequestedItems = _keyValue.ResponseRequestedItems;
                    tempNad.ReturnMe       = _keyValue.ReturnMe;
                    tempNad.NameAndAddress = new WebApiServices.Models.NameAndAddress();



                    //if (details != null)
                    //{
                    //tempNad.NameAndAddress.FirstName = details.FirstName;
                    //tempNad.NameAndAddress.Surname = details.Surname;
                    //tempNad.NameAndAddress.Title = details.Title;
                    //tempNad.NameAndAddress.Dob = details.Dob;

                    //if (details.Address.GetType() == typeof(WebApiServices.Models.Customer.CorrespondenceAddress))
                    //{
                    //    WebApiServices.Models.Customer.CorrespondenceAddress a = details.Address as WebApiServices.Models.Customer.CorrespondenceAddress;

                    //    tempNad.NameAndAddress.Address.Address1 = a.Address1;
                    //    tempNad.NameAndAddress.Address.Address2 = a.Address2;
                    //    tempNad.NameAndAddress.Address.Address3 = a.Address3;
                    //    tempNad.NameAndAddress.Address.Address4 = a.Address4;
                    //    tempNad.NameAndAddress.Address.Postcode = a.Postcode;

                    //}
                    //else if(details.Address.GetType() == typeof(WebApiServices.Models.Customer.TransactionalAddress))
                    //{
                    //    WebApiServices.Models.Customer.TransactionalAddress a = details.Address as WebApiServices.Models.Customer.TransactionalAddress;

                    //    tempNad.NameAndAddress.Address = new Address()
                    //    {
                    //        Address1 = a.HouseNumber + (string.IsNullOrEmpty(a.HouseNumber) == false ? " " : "") + a.Street,
                    //        Address2 = a.Street1,
                    //        Address3 = a.City,
                    //        Address4 = a.County,
                    //        Postcode = a.Postcode
                    //    };

                    //}

                    //var permissionProcess = new ProcessPermission(_keyValue, _permissionService, _mciRequestService, _logger, _nameAndAddress);
                    var permissionProcess = new ProcessPermission(_keyValue, _permissionService, _mciRequestService, _logger, tempNad);
                    output[processedObject] = permissionProcess.ProcessPermissionFromKeyValue();
                    processedObject++;
                    // }
                }

                //if (_keyValue.ReturnMe.Membership != null && _keyValue.ReturnMe.Membership.Required)
                //{
                //    var membershipProcess = new MembershipProcess(_keyValue, _membershipService,
                //        _mciRequestService, _logger);
                //    var memberObj = membershipProcess.ProcessMembershipWithKeyValue();
                //    output[_processedObject] = memberObj;
                //    _processedObject++;
                //    if (memberObj != null && (memberObj.GetType() != typeof(NoAccessToMembership)))
                //    {
                //        //need to resize the array to accommodate the membershipstatus, membershipCancelReason and MembershipStatusReason values
                //        //that are retrieved from GMD to populate the frontend e.g AFE
                //        Array.Resize(ref output, output.Length + 1);
                //        output[_processedObject] = membershipProcess.GetMembershipOptionsData();
                //        _processedObject++;
                //    }
                //}

                //if (_keyValue.ReturnMe.CustomerDetails != null && _keyValue.ReturnMe.CustomerDetails.Required)
                //{
                //    CustomerInfo info = new CustomerInfo();
                //    var customerDetails = new CustomerDetailsProcess(_keyValue, _customerDetailsService,_logger);
                //    info.CustomerDetails = customerDetails.Process();
                //    output[_processedObject] = info;
                //    _processedObject++;
                //}

                //if (_keyValue.ReturnMe.TravelSummary != null && _keyValue.ReturnMe.TravelSummary.Required)
                //{
                //    var travelSummary = new CustomerMatchProcess(_nameAndAddress, _customerMatchService, _travelSummaryService, _logger);
                //    output[_processedObject] = travelSummary.TravelSummaryProcess(int.Parse(_keyValue.KeyValue.Value));
                //    _processedObject++;
                //}
            }
            catch (Exception ex)
            {
                _logger.Error($"{this.GetType().Name}: ErrorTag: {ErrorTagProvider.ErrorTag} -- {ex.Message}", ex);
                throw new Exception(ex.Message);
            }

            return(output);
        }
        public object[] Execute(NameAndAddressParameter nameAndAddress)
        {
            int processedObject = 0;

            _nameAndAddress = nameAndAddress;

            object[] output = new object[_nameAndAddress.ResponseRequestedItems.Count];
            try
            {
                foreach (var item in _nameAndAddress.ResponseRequestedItems)
                {
                    switch (item)
                    {
                    case ReturnMeTypeConstant.CustomerKeys:
                        //CustomerKeyProcess customerKeyProcess = new CustomerKeyProcess(_keyValue,
                        //    _mciRequestService, _clientScopeService, _logger, _nameAndAddress);
                        //output[processedObject] = customerKeyProcess.ProcessForNameAndAddress( _nameAndAddress, _keyValue );
                        //
                        output[processedObject] = _customerKeyProcess.ProcessForNameAndAddress(_nameAndAddress, _keyValue);
                        // AE Feb 18 : Use process from DI container

                        processedObject++;
                        break;

                    case ReturnMeTypeConstant.MailingHistory:
                        MailingHistoryProcess mailingHistoryProcess = new MailingHistoryProcess(_nameAndAddress,
                                                                                                _mailingHistoryService, _mciRequestService, _clientScopeService, _logger, _keyValue);
                        output[processedObject] = mailingHistoryProcess.Process();
                        processedObject++;
                        break;

                    case ReturnMeTypeConstant.Permissions:
                        var processPermission = new ProcessPermission(_keyValue, PermissionService,
                                                                      _mciRequestService, _logger, _nameAndAddress);
                        output[processedObject] = processPermission.ProcessPermissionForNameAndAddress();
                        processedObject++;
                        break;

                    case ReturnMeTypeConstant.Membership:

                        // GITCS-1 : Refactor to NameAndAddressStrategyMembershipReaderParts, in place of MembershipProcess class
                        //
                        var membershipDetailReader =
                            _nameAndAddressReaders[
                                NameAndAddressStrategyReaderImplementations.MembershipDetailsReaderPart];
                        var memberObj = membershipDetailReader.Process(_nameAndAddress,
                                                                       _keyValue?.KeyValue.IntValue);

                        /*
                         * var membershipProcess = new MembershipProcess(_keyValue, _membershipService,
                         *  _mciRequestService, _logger, _nameAndAddress);
                         * var memberObj = membershipProcess.GetMembershipFromNameAndAddress();
                         */

                        output[processedObject] = memberObj;
                        processedObject++;

                        if (memberObj != null && (memberObj.GetType() != typeof(NoAccessToMembership)))
                        {
                            //need to resize the array to accommodate the membershipstatus, membershipCancelReason and MembershipStatusReason values
                            //that are retrieved from GMD to populate the frontend e.g AFE
                            Array.Resize(ref output, output.Length + 1);
                            // output[processedObject] = membershipProcess.GetMembershipOptionsData();

                            //var membershipOptionsReader =
                            //    _nameAndAddressReaders[
                            //        NameAndAddressStrategyReaderImplementations.MembershipOptionsReaderPart ];
                            output[processedObject] = _membershipOptionsReader.Process(_nameAndAddress, null);

                            processedObject++;
                        }

                        break;

                    case ReturnMeTypeConstant.CustomerMatch:
                        var customerMatch          = new CustomerMatchProcess(_nameAndAddress, _customerMatchService, _travelSummaryService, _logger);
                        var matchedCustomerDetails = customerMatch.Process();
                        output[processedObject] = matchedCustomerDetails;
                        processedObject++;
                        break;

                    case ReturnMeTypeConstant.TravelSummary:
                        var travelSummary = new CustomerMatchProcess(_nameAndAddress, _customerMatchService, _travelSummaryService, _logger);
                        output[processedObject] = travelSummary.TravelSummaryProcess(0, _nameAndAddress.NameAndAddress);
                        processedObject++;
                        break;
                    }
                }
            }

            catch (Exception ex)
            {
                _logger.Error(
                    "NameAndAddressStrategy: " + "ErrorTag: " + ErrorTagProvider.ErrorTag + " -- " + ex.Message, ex);
                throw new Exception(ex.Message);
            }
            return(output);
        }
        public IHttpActionResult Post(PermissionsCustomerLoad permissions)
        {
            try
            {
                var mappedPermissions = Mapper.Map <WebApiServices.Models.Gdpr.PermissionsCustomerLoadModel>(permissions);
                var processPermission =
                    new ProcessPermission(null, _permissionsService, _mciRequestService, _logger, null);
                var message = processPermission.AddOrUpdateCustomerPermission(mappedPermissions);

                //Post show return summary instead of message if the load is successfully
                if (string.Compare(DatabaseMessage.PermissionsCreated, message,
                                   StringComparison.CurrentCultureIgnoreCase) == 0)
                {
                    if ((!string.IsNullOrWhiteSpace(permissions.CustomerNameAndAddress.FirstName)) &&
                        (!string.IsNullOrWhiteSpace(permissions.CustomerNameAndAddress.Surname)) &&
                        (permissions.CustomerNameAndAddress.Address != null))
                    {
                        NameAndAddressParameter parameter = new NameAndAddressParameter()
                        {
                            NameAndAddress = permissions.CustomerNameAndAddress, ResponseRequestedItems = new List <string>()
                            {
                                ReturnMeTypeConstant.Permissions.ToString()
                            }
                        };

                        parameter.ReturnMe = new ReturnMe()
                        {
                            Permissions = new ReturnMePermissions
                            {
                                Required            = true,
                                Journey             = permissions.JourneyType,
                                ResponseParameter   = GdprResponseType.Summary.ToString(),
                                PermissionParameter = "All",
                                MatchType           = Saga.Gmd.WebApiServices.Common.MatchType.POSTCODE_AND_NAME.ToString()
                            }
                        };
                        parameter.NameAndAddress.MatchType = Saga.Gmd.WebApiServices.Common.MatchType.POSTCODE_AND_NAME
                                                             .ToString();

                        // Use indexed DI resoloution to get the required strategy
                        IGetRequestProcess nameAndAddress = _strategyProcesses[GetRequestProcessImplementations.NameAndAddress];

                        //NameAndAddressStrategy nameAndAddress = new NameAndAddressStrategy(parameter,
                        //    _mailingHistoryService, _mciRequestService, _clientScopeService, _logger, _permissionsService,
                        //    _membershipService, _customerMatchService, _customerDetailsService, _travelSummaryService);
                        parameter.AccessControl =
                            _clientScopeService.VerifyUserHasAccessToGroupCode(parameter.AccessControl,
                                                                               Scope.CUSTOMER_PERMISSIONS_RETRIEVE_NAMEADDR);
                        object output = nameAndAddress.Execute(parameter);
                        return(Ok(output));
                    }
                    else
                    {
                        KeyValueParameter parameter = new KeyValueParameter()
                        {
                            ResponseRequestedItems = new List <string>()
                            {
                                ReturnMeTypeConstant.Permissions.ToString()
                            },
                            KeyValue = new KeyValue()
                            {
                                Key = "CPCK", Value = permissions.PermissionsId.ToString()
                            }
                        };

                        parameter.ReturnMe = new ReturnMeForKeyValuePair()
                        {
                            Permissions = new ReturnMePermissions
                            {
                                Required            = true,
                                Journey             = permissions.JourneyType,
                                ResponseParameter   = GdprResponseType.Summary.ToString(),
                                PermissionParameter = "All"
                            }
                        };

                        // Use indexed DI resoloution  to get the required strategy
                        IGetRequestProcess strategy = _strategyProcesses[GetRequestProcessImplementations.PermissionsKeyValuePair];

                        //PermissionsKeyValuePairStrategy strategy = new PermissionsKeyValuePairStrategy(parameter, _mailingHistoryService,
                        //    _mciRequestService, _clientScopeService,
                        //    _logger, _permissionsService,
                        //    _membershipService, _customerDetailsService,
                        //    _travelSummaryService, _customerMatchService);
                        object output = strategy.Execute(parameter);
                        return(Ok(output));
                    }
                }
                return(Ok(message));
            }
            catch (Exception exception)
            {
                if (_logParameterValue)
                {
                    _logger.Error($"PermissionGetNameAndAddress: ErrorTag: {ErrorTagProvider.ErrorTagDatabase} --  {exception.Message}");

                    _logger.Error(
                        $"Parameters PermissionLoad:- Name=FirstName={permissions.CustomerNameAndAddress.FirstName}, LastName={permissions.CustomerNameAndAddress.Surname}, Dob={permissions.CustomerNameAndAddress.Dob}, " +
                        $" Address=AddresLine1={ permissions.CustomerNameAndAddress.Address.Address1 ?? ""}, AddressLine2={permissions.CustomerNameAndAddress.Address.Address2 ?? ""}, AddressLine3={permissions.CustomerNameAndAddress.Address.Address3 ?? ""}, " +
                        $" AddressLine4={permissions.CustomerNameAndAddress.Address.Address4 ?? ""}, PostCode={permissions.CustomerNameAndAddress.Address.Postcode ?? ""}");
                }
                return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message)));
            }
        }