public async Task <HttpResponseMessage> DeleteMember(string itxt)
        {
            try
            {
                long result = await AccountInfoWorkFlow.DeleteMemberAccountById(itxt);

                var message = Request.CreateResponse(HttpStatusCode.Created, " deleted: " + result);
                message.Headers.Location = new Uri(Request.RequestUri + " deleted for: " + itxt);

                return(message);
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
            }
        }
        public async Task <HttpResponseMessage> RecordLoginDay(string itxt, string loginDay)
        {
            try
            {
                long result = await AccountInfoWorkFlow.RecordLoginDay(itxt, loginDay);

                var message = Request.CreateResponse(HttpStatusCode.Created, " modified: " + result.ToString());
                message.Headers.Location = new Uri(Request.RequestUri + " saved login day for : " + itxt);

                return(message);
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
            }
        }
        public async Task <HttpResponseMessage> ArchiveMember(string itxt)
        {
            try
            {
                long result = await AccountInfoWorkFlow.ArchiveAccount(itxt);

                var message = Request.CreateResponse(HttpStatusCode.Created, " modified: " + result.ToString());
                message.Headers.Location = new Uri(Request.RequestUri + " pending for : " + itxt);

                return(message);
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
            }
        }
        public async Task <HttpResponseMessage> UpdateMemberAccount([FromBody] AccountInfo mai)
        {
            try
            {
                long result = await AccountInfoWorkFlow.UpdateMemberAccount(mai);

                var message = Request.CreateResponse(HttpStatusCode.Created, " modified: " + result.ToString());
                message.Headers.Location = new Uri(Request.RequestUri + " account email: " + mai._email);

                return(message);
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
            }
        }
        public async Task <HttpResponseMessage> AddOneMember([FromBody] AccountInfo mai)
        {
            try
            {
                mai._password = UIHelperController.EncryptDataMD5(mai._password);
                await AccountInfoWorkFlow.CreateMemberAccount(mai);

                var message = Request.CreateResponse(HttpStatusCode.Created, mai);
                message.Headers.Location = new Uri(Request.RequestUri + " added account: " + mai._email);

                return(message);
            }
            catch (Exception e)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
            }
        }
        public IHttpActionResult SearchMemberById(string itxt)
        {
            List <AccountInfo> lstAccount = new List <AccountInfo>();

            try
            {
                lstAccount = AccountInfoWorkFlow.GetMemberById(itxt);
                return(Ok(lstAccount));
            }
            catch (Exception e)
            {
                var httpResponse = new HttpResponseMessage {
                };
                IHttpActionResult response;

                httpResponse.StatusCode = HttpStatusCode.Unauthorized;
                response = ResponseMessage(httpResponse);
                return(response);
            }
        }
        public IHttpActionResult SearchDuplicateEmail(string email)
        {
            bool isExisted = false;

            try
            {
                isExisted = AccountInfoWorkFlow.CheckEmail(email);
                return(Ok <bool>(isExisted));
            }
            catch (Exception e)
            {
                var httpResponse = new HttpResponseMessage {
                };
                IHttpActionResult response;

                httpResponse.StatusCode = HttpStatusCode.Unauthorized;
                response = ResponseMessage(httpResponse);
                return(response);
            }
        }
        public IHttpActionResult SearchMemberByLocation(int count, string neighbourhood, string cityName, string provinceCode, string countryName)
        {
            List <AccountInfo> lstAccount = new List <AccountInfo>();

            try
            {
                lstAccount = AccountInfoWorkFlow.GetActiveMemberAccountByLocation(count, neighbourhood, cityName, provinceCode, countryName);
                return(Ok(lstAccount));
            }
            catch (Exception e)
            {
                var httpResponse = new HttpResponseMessage {
                };
                IHttpActionResult response;

                httpResponse.StatusCode = HttpStatusCode.Unauthorized;
                response = ResponseMessage(httpResponse);
                return(response);
            }
        }
        public IHttpActionResult MemberAuthenticate([FromBody] AccountInfo mai)
        {
            var loginResponse       = new HttpResponseMessage {
            };
            AccountInfo AccountInfo = new AccountInfo();

            IHttpActionResult   response;
            HttpResponseMessage responseMsg = new HttpResponseMessage();
            bool isUsernamePasswordValid    = false;

            if (mai != null)
            {
                AccountInfo._email    = mai._email;
                AccountInfo._password = mai._password;

                List <AccountInfo> lstAccount = new List <AccountInfo>();
                lstAccount = AccountInfoWorkFlow.GetMemberAccountLoginInfo(AccountInfo._email, UIHelperController.EncryptDataMD5(AccountInfo._password));

                if (lstAccount.Count > 0)
                {
                    isUsernamePasswordValid = true;
                }
            }

            // if credentials are valid
            if (isUsernamePasswordValid)
            {
                string token = CreateToken(AccountInfo._email);
                //return the token
                return(Ok <string>(token));
            }
            else
            {
                // if credentials are not valid send unauthorized status code in response
                loginResponse.StatusCode = HttpStatusCode.Unauthorized;
                response = ResponseMessage(loginResponse);
                return(response);
            }
        }