public PaymentResult ProcessPayment(ViewModels.CheckoutViewModel model)
        {
            var request = new TransactionRequest()
            {
                Amount = model.Total,
                CreditCard = new TransactionCreditCardRequest()
                {
                    Number = model.CardNumber,
                    CVV = model.Cvv,
                    ExpirationMonth = model.Month,
                    ExpirationYear = model.Year
                },
                Options = new TransactionOptionsRequest()
                {
                    SubmitForSettlement = true
                }
            };

            var result = _gateway.Transaction.Sale(request);

            if (result.IsSuccess())
            {
                return new PaymentResult(result.Target.Id, true, null);
            }

            return new PaymentResult(null, false, result.Message);
        }

        public bool RegisterCustomer(ViewModels.CustomerRegisterModel model)
        {
            using (var dbContext = new PaymentGatewayDbContext())
            {
                var customer = new Person
                {
                    FullName = model.FullName,
                    DoB = model.DoB
                };
                customer.Accounts.Add(new Account { Balance = model.InitialDeposit });

                var credential = new Credentials
                {
                    UserName = model.UserName,
                    Person = customer,
                    CreatedDate = DateTimeOffset.Now,
                    SecretKey = criptoService.GenerateRandomByte(512)
                };

                using (SHA512 shasum = SHA512.Create())
                {
                    credential.HashedPassword = shasum.ComputeHash(Encoding.Default.GetBytes(model.Password));
                }
                dbContext.Credentials.Add(credential);
                dbContext.SaveChanges();
                return true;
            }
        }

        public ActionResult AssignContact(ViewModels.Events.EventAssignedContactViewModel model)
        {
            Common.Models.Account.Users currentUser;
            Common.Models.Events.EventAssignedContact eventContact;

            // We need to reset the Id of the model as it is picking up the id from the route,
            // which is incorrect
            model.Id = null;

            currentUser = Data.Account.Users.Get(User.Identity.Name);

            eventContact = Data.Events.EventAssignedContact.Get(model.Event.Id.Value, model.Contact.Id.Value);

            if (eventContact == null)
            { // Create
                eventContact = Mapper.Map<Common.Models.Events.EventAssignedContact>(model);
                eventContact = Data.Events.EventAssignedContact.Create(eventContact, currentUser);
            }
            else
            { // Enable
                eventContact = Mapper.Map<Common.Models.Events.EventAssignedContact>(model);
                eventContact = Data.Events.EventAssignedContact.Enable(eventContact, currentUser);
            }

            return RedirectToAction("Contacts", "Events",
                new { id = eventContact.Event.Id.Value.ToString() });
        }

        public Task Create(ViewModels.TaskViewModel model)
        {
            if (ToadyCount() < 5)
            {
                Task entity = new Task();
                entity.Start = model.Start;

                entity.End = model.Start.AddHours(8);
                entity.EndTimeZone = entity.End.ToString("yyyy-MM-dd");
                entity.StartTimeZone = model.Start.ToString("yyyy-MM-dd");

                //entity.Title = model.Title;
                entity.Description = model.Description;
                entity.MemberID = model.MemberID;
                entity.AddUser = CookieHelper.MemberID;
                entity.AddTime = DateTime.Now;
                if (model.MemberID != CookieHelper.MemberID)
                {
                    entity.IsOtherAdd = true;
                }
                db.Add<Task>(entity);
                db.Commit();
                return entity;
            }
            else
            {
                throw new Exception("当天任务安排不能超过5条");
            }
        }

        public ActionResult AssignContact(ViewModels.Matters.MatterContactViewModel model)
        {
            Common.Models.Account.Users currentUser;
            Common.Models.Matters.MatterContact matterContact;

            // We need to reset the Id of the model as it is picking up the id from the route,
            // which is incorrect
            model.Id = null;

            currentUser = Data.Account.Users.Get(User.Identity.Name);

            matterContact = Data.Matters.MatterContact.Get(model.Matter.Id.Value, model.Contact.Id.Value);

            if (matterContact == null)
            { // Create
                matterContact = Mapper.Map<Common.Models.Matters.MatterContact>(model);
                matterContact = Data.Matters.MatterContact.Create(matterContact, currentUser);
            }
            else
            { // Enable
                matterContact = Mapper.Map<Common.Models.Matters.MatterContact>(model);
                matterContact = Data.Matters.MatterContact.Enable(matterContact, currentUser);
            }

            if (model.Role == "Lead Attorney")
            {
                Common.Models.Matters.Matter matter = Data.Matters.Matter.Get(model.Matter.Id.Value);
                matter.LeadAttorney = Mapper.Map<Common.Models.Contacts.Contact>(model.Contact);
                Data.Matters.Matter.Edit(matter, currentUser);
            }

            return RedirectToAction("Contacts", "Matters",
                new { id = matterContact.Matter.Id.Value.ToString() });
        }

        public ActionResult Login(ViewModels.Account.LoginViewModel viewModel, string returnUrl)
        {
            if (ModelState.IsValid)
            {
                if (MembershipService.ValidateUser(viewModel.Username, viewModel.Password))
                {
                    FormsService.SignIn(viewModel.Username, viewModel.RememberMe);
                    if (!string.IsNullOrEmpty(returnUrl))
                    {
                        return Redirect(returnUrl);
                    }
                    else
                    {
                        return RedirectToAction("Index", "Home");
                    }
                }
                else
                {
                    ModelState.AddModelError("", "The user name or password provided is incorrect.");
                }
            }

            // If we got this far, something failed, redisplay form
            return View(viewModel);
        }

 void GetReviewCompleted(object s, ViewModels.DoubanSearchCompletedEventArgs args)
 {
     App.SubjectReviewViewModel.GetReviewCompleted -= GetReviewCompleted;
     Deployment.Current.Dispatcher.BeginInvoke(() =>
     {
         if (args.IsSuccess)
         {
             contentContainer.Visibility = Visibility.Visible;
             contentContainer.IsEnabled = false;
             DataContext = args.Result;
             this.SetProgressIndicator(false);
             contentContainer.IsEnabled = true;
             foreach (var content in App.SubjectReviewViewModel.ReveiwContentList)
             {
                 TextBlock tb = new TextBlock();
                 //tb.Width = 445;
                 tb.TextWrapping = TextWrapping.Wrap;
                 tb.Foreground = new SolidColorBrush(Colors.Black);
                 tb.FontSize = (double)App.Current.Resources["PhoneFontSizeMedium"];
                 tb.Text = content;
                 spContent.Children.Add(tb);
             }
             contentContainer.ScrollToVerticalOffset(0);
         }
         else
         {
             ToastPrompt toast = new ToastPrompt();
             toast.Message = args.Message;
             toast.Show();
         }
     });
 }

        public override void CalculateWinnings(ViewModels.CasinoNumberViewModel drawnNumber)
        {
            foreach (var bet in _LastBets)
                CalculateWinningsOnBet(bet, drawnNumber);

            _LastBets.Clear();
        }

        public ActionResult Configuration(ViewModels.SetupWizard.Configuration model)
        {
            if (ModelState.IsValid)
            {

                try
                {
                    //Tryout the connection string to see if it's valid
                    _dbVersionLogic.CheckDbAccess(model.AzureSQL);

                }
                catch (Exception ex)
                {
                    ModelState.AddModelError("AzureSQL", "Provided connection string is not valid");
                    return View(model);
                }

                //setup database
                _dbVersionLogic.GenerateInitialDatabase(model.AzureSQL);

                var configObj = WebConfigurationManager.OpenWebConfiguration("~");
                var connStringSection = (ConnectionStringsSection)configObj.GetSection("connectionStrings");
                connStringSection.ConnectionStrings["AzureSQL"].ConnectionString = model.AzureSQL;
                var appSettingsSection = (AppSettingsSection)configObj.GetSection("appSettings");
                appSettingsSection.Settings["BaseURL"].Value = model.BaseURL;
                appSettingsSection.Settings["SetupComplete"].Value = "true";
                configObj.Save();

                return RedirectToAction("index", "Home");

            }
            return View(model);
        }

        public CustomerCompany Create(ViewModels.CustomerCompanyViewModel model)
        {
            CustomerCompany entity = new CustomerCompany();
            entity.Name = model.Name;
            entity.BrandName = model.BrandName;
            entity.IndustryID = Utilities.GetCascadingId(model.IndustryCode);
            entity.IndustryValue = model.IndustryCode;
            entity.CustomerCateID = model.CustomerCateID;
            entity.CityID = Utilities.GetCascadingId(model.CityCode);
            entity.CityValue = model.CityCode;
            entity.Address = model.Address;
            entity.AddTime = DateTime.Now;
            entity.AddUser = CookieHelper.MemberID;
            entity.Description = model.Description;
            entity.Fax = model.Fax;
            entity.LastTime = DateTime.Now;
            entity.LastUser = CookieHelper.MemberID;
            entity.Phone = model.Phone;

            //entity.Finance = model.Finance;
            //entity.FinancePhone = model.FinancePhone;
            entity.ProxyName = model.ProxyName;
            entity.ProxyPhone = model.ProxyPhone;
            entity.ProxyAddress = model.ProxyAddress;
            entity.RelationID = model.RelationID;
            db.Add<CustomerCompany>(entity);
            db.Commit();
            return entity;
        }

        public ActionResult ChartYearly(ViewModels.PmsSummary.ChartViewModel viewModel)
        {
            var artifactDesignerViewModel = new ArtifactDesignerViewModel();
            artifactDesignerViewModel.BarChart = new BarChartViewModel();
            var previewViewModel = new ArtifactPreviewViewModel();
            artifactDesignerViewModel.BarChart.Series.Add(new BarChartViewModel.SeriesViewModel
            {
                KpiId = viewModel.Id,
                Label = "Achievement",
                ValueAxis = ValueAxis.KpiActual.ToString()
            });

             var request = new GetCartesianChartDataRequest();
            request.GraphicName = "Yearly";
            request.GraphicType = "barachievement";
            request.HeaderTitle = "Yearly";
            request.MeasurementId = viewModel.MeasurementId;
            request.PeriodeType = PeriodeType.Yearly;
            request.RangeFilter = RangeFilter.CurrentYear;
            request.ValueAxis = ValueAxis.KpiActual;

            artifactDesignerViewModel.BarChart.MapPropertiesToInstance<GetCartesianChartDataRequest>(request);
            var chartData = _artifactService.GetChartData(request);
            previewViewModel.GraphicType = "barachievement";
            previewViewModel.BarChart = new BarChartDataViewModel();
            previewViewModel.BarChart.Title = "Yearly";
            previewViewModel.BarChart.ValueAxisTitle = _measurementService.GetMeasurement(new GetMeasurementRequest { Id = viewModel.MeasurementId }).Name;
            previewViewModel.BarChart.Series = chartData.Series.MapTo<BarChartDataViewModel.SeriesViewModel>();
            previewViewModel.BarChart.Periodes = chartData.Periodes;
            previewViewModel.BarChart.SeriesType = chartData.SeriesType;
            return Json(previewViewModel, JsonRequestBehavior.AllowGet);
        }

        public ActionResult Edit(int id, ViewModels.Tasks.TaskTemplateViewModel viewModel)
        {
            Common.Models.Account.Users currentUser;
            Common.Models.Tasks.TaskTemplate model;

            using (Data.Transaction trans = Data.Transaction.Create(true))
            {
                try
                {
                    currentUser = Data.Account.Users.Get(trans, User.Identity.Name);

                    model = Mapper.Map<Common.Models.Tasks.TaskTemplate>(viewModel);

                    model = Data.Tasks.TaskTemplate.Edit(trans, model, currentUser);

                    trans.Commit();

                    return RedirectToAction("Details", new { Id = id });
                }
                catch
                {
                    trans.Rollback();
                    return Edit(id);
                }
            }
        }

        private void MatterContactAssignment(
            ViewModels.Matters.MatterContactViewModel viewModel, 
            Common.Models.Matters.Matter matter,
            Common.Models.Account.Users currentUser, 
            Data.Transaction trans)
        {
            if (viewModel != null && viewModel.Contact != null
                && viewModel.Contact.Id.HasValue)
            {
                Common.Models.Matters.MatterContact mcOld;

                mcOld = Data.Matters.MatterContact.Get(matter.Id.Value, viewModel.Contact.Id.Value);

                if (mcOld == null)
                { // Create
                    Common.Models.Matters.MatterContact mcNew;
                    mcNew = Mapper.Map<Common.Models.Matters.MatterContact>(viewModel);
                    mcNew.Matter = matter;
                    mcNew = Data.Matters.MatterContact.Create(trans, mcNew, currentUser);
                }
                else
                { // Enable
                    Common.Models.Matters.MatterContact mcNew;
                    mcNew = Mapper.Map<Common.Models.Matters.MatterContact>(viewModel);
                    mcNew.Matter = matter;
                    mcNew.Id = mcOld.Id;
                    mcNew = Data.Matters.MatterContact.Enable(trans, mcNew, currentUser);
                    mcNew = Data.Matters.MatterContact.Edit(trans, mcNew, currentUser);
                }
            }
        }

 public Customer Create(ViewModels.CustomerViewModel model)
 {
     Customer entity = new Customer();
     entity.Name = model.Name;
     entity.Address = model.Address;
     entity.AddTime = DateTime.Now;
     entity.AddUser = CookieHelper.MemberID;
     entity.ReMark = model.ReMark;
     entity.IsLeap = model.IsLeap;
     if (entity.IsLeap)
     {
         entity.BirthDay1 = Utilities.GetLunarStringOnlyMonthDay(model.BirthDay);
     }
     entity.BirthDay = model.BirthDay;
     entity.CompanyID = model.CompanyID;
     entity.Email = model.Email;
     entity.Favorite = model.Favorite;
     entity.JobID = model.JobID;
     entity.Jobs = model.Jobs;
     entity.LastTime = DateTime.Now;
     entity.LastUser = 1;
     entity.Mobile = model.Mobile;
     entity.Mobile1 = model.Mobile1;
     entity.Phone = model.Phone;
     entity.QQ = model.QQ;
     db.Add<Customer>(entity);
     db.Commit();
     return entity;
 }

        public LogOnServerDialog(ViewModels.LogonServerViewModel viewModel)
        {
            InitializeComponent();

            this.DataContext = viewModel;
            viewModel.CurrentWindow = this;
        }

        public ActionResult Edit(ViewModels.Assets.FileViewModel viewModel)
        {
            Common.Models.Account.Users currentUser;
            Common.Models.Assets.File file;

            using (Data.Transaction trans = Data.Transaction.Create())
            {
                try
                {
                    currentUser = Data.Account.Users.Get(User.Identity.Name);
                    file = Data.Assets.File.Get(trans, viewModel.Id.Value);
                    Common.Models.Assets.Version version = Data.Assets.Version.Get(trans, file.Version.Id.Value);

                    
                    file = Mapper.Map<Common.Models.Assets.File>(viewModel);

                    file = Data.Assets.File.Edit(trans, file, currentUser);

                    trans.Commit();

                    return RedirectToAction("Details", "Assets", new { Id = version.Asset.Id.Value });
                }
                catch (Exception ex)
                {
                    trans.Rollback();

                    throw ex;
                }
            }
        }

        public virtual ActionResult LogIn(ViewModels.Login.Index vm)
        {
            var logger = ObjectFactory.GetInstance<Logger>();
            logger.Info("[Controllers].[LoginController].[LogIn] invoked.");

            ActionResult result;
            var session = ObjectFactory.GetInstance<UserSession>();

            var validator = new Validators.Login.LogIn(vm);
            logger.Info("[Controllers].[LoginController].[LogIn] [validator].[IsValid] = '{0}'.", validator.IsValid);

            if (!validator.IsValid)
            {
                vm.Notifications.Clear();
                vm.Notifications.AddRange(validator.Errors);
                result = View(MVC.Login.Views.Index, vm);
                logger.Info("[Controllers].[LoginController].[LogIn] returned validation errors.");
            }
            else
            {
                session.SignIn(validator.Result.Username);
                result = ControllerContext.GetRedirectResult(MVC.Default.Index());
                logger.Info("[Controllers].[LoginController].[LogIn] successfully signed in.");
            }
            logger.Info("[Controllers].[LoginController].[LogIn] [vm].[Username] == '{0}'.", vm.Username);

            logger.Trace("[Controllers].[LoginController].[LogIn] finished work.");
            return result;
        }

 private void ProcessLineInSettingsEditor(ViewModels.WaveInChannelSourceModel model)
 {
     if (model == null)
         return;
     RadioLog.Windows.WaveInChannelSourceEditorDialog editor = new Windows.WaveInChannelSourceEditorDialog(model.SrcInfo);
     editor.ShowDialog();
 }

        public Task<ViewModels.IReceiveResult> Invoke(Root root, Method method, ViewModels.IReceiveResult result)
        {
            result.Result = "";
            try
            {
                var parsed = Build.Controller(method.ClassName)
                               .Action(method.Name)
                               .Parameters(method.Parameters.ToDictionary(p => p.Name, p => p.Value));
                var returned = parsed.Invoke();

                foreach (var yielded in returned)
                {
                    result.Result += yielded;
                }
            }
            catch (TypeConversionFailedException ex)
            {
                var errorObject = new TypeConversionFailed
                {
                    Message = ex.Message,
                    Argument = ex.Argument,
                    TargetType = ex.TargetType.ToString(),
                    Value = ex.Value
                };
                result.Errors = new[] { errorObject };
            }
            catch (MissingArgumentException ex)
            {
                result.Errors = ex.Arguments
                    .Select(a => new MissingArgument { Message = ex.Message, Argument = a })
                    .ToArray();
            }
            return Task.FromResult(result);
        }

        public ActionResult Create(ViewModels.CreateActionItem toCreate)
        {
            List<Models.ActionItemStatus> companyActionItemStatuses = DAL.loadCompanyActionItemStatuses(CurrentCompany.ID);
            List<Models.ActionItemType> companyActionItemTypes = DAL.loadCompanyActionItemTypes(CurrentCompany.ID);
            List<Models.Priority> priorities = CurrentCompany.Priorities;

            //var assignedUsers = toEdit.CurrentActionItem.AssignedTo.Select(x => DAL.loadUserById(x.ID, false));
            var assignedUsers = DAL.loadUserById(toCreate.SelectedUser.ID, false);
            toCreate.CurrentActionItem.AssignedTo = new List<Models.User>() { assignedUsers };//assignedUsers.ToList();

            toCreate.CurrentActionItem.CurrentPriority = priorities.FirstOrDefault(x => x.Order == toCreate.CurrentActionItem.CurrentPriority.Order);
            toCreate.CurrentActionItem.CurrentStatus = companyActionItemStatuses.FirstOrDefault(x => x.ID == toCreate.CurrentActionItem.CurrentStatus.ID);
            toCreate.CurrentActionItem.CurrentType = companyActionItemTypes.FirstOrDefault(x => x.ID == toCreate.CurrentActionItem.CurrentType.ID);

            toCreate.CurrentActionItem.AssignedTo = new List<Models.User>() { DAL.loadUserById(toCreate.SelectedUser.ID, false) };
            #warning figure out a way to parse the Estimate based on generic text input like "two hours" or "2h".
            toCreate.CurrentActionItem.Estimate = null;
            toCreate.CurrentActionItem.CreatedBy = CurrentUser;
            toCreate.CurrentActionItem.DateCreated = DateTime.UtcNow;

            Models.Release targetRelease = DAL.loadReleaseById(toCreate.SelectedRelease.ID);

            DAL.createNewActionItem(CurrentUser, targetRelease, toCreate.CurrentActionItem, CurrentUser);

            return RedirectToAction("Overview", "Project");
        }