public EntityOperationResultBase SaveExternalOrder(List<ExternalOrder> orders)
        {
            EntityOperationResultBase updateResult = new EntityOperationResultBase() { Success = false };
            try
            {
                using (InnoventoryDBContext dbContext = new InnoventoryDBContext())
                {
                    DbSet<ExternalOrder> externalOrderSet = dbContext.ExternalOrderSet;

                    foreach (var order in orders)
                    {

                        ExternalOrder existingOrder = externalOrderSet.Where(x => x.StoreProviderOrderId == order.StoreProviderOrderId).FirstOrDefault();

                        if (existingOrder == null)
                        {
                            order.OrderStatus = (int)StoreOrderStatusEnum.Unshipped;
                            order.StoreOrderHeaderId = Guid.NewGuid();
                            order.ShippedDate = null;
                            order.JsonShippingAddress = JsonConvert.SerializeObject(order.ShippingAddress);
                            dbContext.ExternalOrderSet.Add(order);

                            foreach (var lineItem in order.ExternalOrderLineItems)
                            {
                                lineItem.ExternalOrderLineItemId = Guid.NewGuid();
                                lineItem.StoreOrderId = order.StoreOrderHeaderId;
                                dbContext.ExternalOrderLineItemSet.Add(lineItem);

                            }

                            dbContext.SaveChanges();
                        }
                    }

                    updateResult.Success = true;
                }
            }
            catch (DbEntityValidationException dbEx)
            {
                var errorMessages = dbEx.EntityValidationErrors
                        .SelectMany(x => x.ValidationErrors)
                        .Select(x => x.ErrorMessage);

                // Join the list to a single string.
                var fullErrorMessage = string.Join("; ", errorMessages);

                // Combine the original exception message with the new one.
                var exceptionMessage = string.Concat(" The validation errors are: ", fullErrorMessage);
                updateResult.Success = false;
                updateResult.ErrorMessage = exceptionMessage;
            }
            catch (Exception ex)
            {
                string ErrorMessage = string.Format("An error {0} occurred while saving changes to database",
                                   ex.Message);
                updateResult.Success = false;
                updateResult.ErrorMessage = ErrorMessage;
            }

            return updateResult;
        }
        public HttpResponseMessage Register(HttpRequestMessage request, [FromBody]AdminUserRegistrationViewModel registerModel)
        {
            HttpResponseMessage response = null;

            if (!ModelState.IsValid)
            {

                response = new HttpResponseMessage(HttpStatusCode.BadRequest);
                return response;
            }

            EntityOperationResultBase resultBase = new EntityOperationResultBase();

            var user = new UserAccount()
            {
                UserName = registerModel.UserName,
                Email = registerModel.Email,
                UserAccountId = Guid.NewGuid(),
                Contact1 = registerModel.Contact1,
                Contact2 = registerModel.Contact2,
                CreatedOn = DateTime.UtcNow,
                FirstName = registerModel.FirstName,
                LastName = registerModel.LastName,
                PasswordChangeDate = DateTime.Now,
                SecretAnswer = "",

            };
            try
            {

                Task<IdentityResult> tsk = Task.Run<IdentityResult>(() => { return UserManager.CreateAsync(user, registerModel.Password); });

                IdentityResult result = tsk.Result;

                resultBase.Success = result.Succeeded;

                if (!result.Succeeded)
                {
                    resultBase.ErrorMessage = string.Join("; ", result.Errors);

                    response = new HttpResponseMessage(HttpStatusCode.InternalServerError);

                    response.Content = new ObjectContent<EntityOperationResultBase>(resultBase, Configuration.Formatters.JsonFormatter);

                    return response;
                }
                else
                {

                    resultBase.SuccessMessage = "User Created successfully";
                }

                response = new HttpResponseMessage(HttpStatusCode.OK);

                response.Content = new ObjectContent<EntityOperationResultBase>(resultBase, Configuration.Formatters.JsonFormatter);
            }
            catch (Exception ex)
            {
                resultBase.Success = false;
                resultBase.ErrorMessage = ex.Message;

                response = new HttpResponseMessage(HttpStatusCode.InternalServerError);

                response.Content = new ObjectContent<EntityOperationResultBase>(resultBase, Configuration.Formatters.JsonFormatter);
            }

            return response;
        }