public async Task <IActionResult> Completed()
{
ApplicationUser currentUser = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> todoItems;
TodoViewModel todoView;
CompletedViewModel model = new CompletedViewModel();
try
{
todoItems = _repository.GetCompleted(Guid.Parse(currentUser.Id));
foreach (TodoItem i in todoItems)
{
todoView = new TodoViewModel(i);
model.Items.Add(todoView);
}
}
catch (ArgumentNullException ex)
{
_repository.AddError(ex.Message);
return(View("Error"));
}
catch (FormatException ex)
{
_repository.AddError(ex.Message);
return(View("Error"));
}
return(View(model));
}
public async Task <IActionResult> Completed([FromRoute(Name = "id")] Guid orderNumber)
{
//get order by order number
PaymentTransaction payment = await _paymentService.GetByOrderNumber(orderNumber, includeBank : true);
if (payment == null)
{
return(RedirectToAction("Index", "Home"));
}
//create completed view model
CompletedViewModel model = new CompletedViewModel
{
OrderNumber = payment.OrderNumber,
TransactionNumber = payment.TransactionNumber,
ReferenceNumber = payment.ReferenceNumber,
BankId = payment.BankId,
BankName = payment.Bank?.Name,
CardHolderName = payment.CardHolderName,
Installment = payment.Installment,
TotalAmount = payment.TotalAmount,
PaidDate = payment.PaidDate,
CreateDate = payment.CreateDate
};
return(View(model));
}
public async Task <IActionResult> Completed(ReservationsRouteModel routeModel)
{
if (!routeModel.Id.HasValue)
{
throw new ArgumentException("Reservation ID must be in URL.", nameof(routeModel.Id));
}
var query = new GetReservationQuery
{
Id = routeModel.Id.Value,
UkPrn = routeModel.UkPrn.GetValueOrDefault()
};
var queryResult = await _mediator.Send(query);
//todo: null check on result, redirect to error
var model = new CompletedViewModel
{
AccountLegalEntityName = queryResult.AccountLegalEntityName,
TrainingDateDescription = new TrainingDateModel()
{
StartDate = queryResult.StartDate,
EndDate = queryResult.ExpiryDate
}.GetGDSDateString(),
CourseDescription = queryResult.Course.CourseDescription,
StartDate = queryResult.StartDate,
CourseId = queryResult.Course?.Id,
UkPrn = queryResult.UkPrn ?? routeModel.ProviderId,
CohortRef = routeModel.CohortReference
};
var viewName = routeModel.UkPrn.HasValue ? ViewNames.ProviderCompleted : ViewNames.EmployerCompleted;
return(View(viewName, model));
}
public IActionResult Completed() //async
{
CompletedViewModel compModel = new CompletedViewModel(_repository, _userId);
var repo = compModel.GetRepos();
return(View(repo));
}
public async Task <IActionResult> Completed()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
CompletedViewModel completedModel = new CompletedViewModel(_repository.GetCompleted(new Guid(user.Id)));
return(View(completedModel));
}
public ActionResult Thanks(CompletedViewModel model)
{
if (model.Message1 != null)
{
model.Message1 = _localizer[model.Message1];
}
return(View(model));
}
public ActionResult Confirm(ReviewViewModel inViewModel)
{
var request = ReviewViewModelMapper.Map(inViewModel);
var bookingNumber = _bookingService.CustomerMake(request);
var outViewModel = new CompletedViewModel();
outViewModel.BookingNumber = bookingNumber;
return(View("Completed", outViewModel));
}
public async Task <IActionResult> Completed()
{
var thisUser = await FetchUser();
var thisModel = new CompletedViewModel((await _repository.GetCompletedAsync(new Guid(thisUser.Id)))
.Select(item => new TodoViewModel(item.Id, item.Text, item.DateDue, true))
.ToList());
return(View(thisModel));
}
public async Task <IActionResult> Completed()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> userCompletedTodoes = await _repository.GetCompleted(new Guid(user.Id));
CompletedViewModel indexViewModel = new CompletedViewModel(userCompletedTodoes);
return(View(indexViewModel));
}
public async Task <ActionResult> Completed()
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> items = _repository.GetCompleted(new Guid(applicationUser.Id));
List <TodoViewModel> todoViewModels = Mapper.Map <List <TodoItem>, List <TodoViewModel> >(items);
CompletedViewModel completedViewModel = new CompletedViewModel(todoViewModels);
return(View(completedViewModel));
}
private CompletedViewModel GetSubscriptionMessage(StripeSubscription result, bool HasSubscriptions)
{
var completedMessage = new CompletedViewModel
{
Message = result.StripePlan.Nickname.Split("_")[1],
Message1 = result.StripePlan.Nickname.Split("_")[0],
HasSubscriptions = HasSubscriptions
};
return(completedMessage);
}
public async Task <IActionResult> Completed()
{
ApplicationUser currentUser = await _user.GetUserAsync(HttpContext.User);
var userId = currentUser.Id;
var a = _repository.GetCompleted(userId);
CompletedViewModel cvm = new CompletedViewModel(a);
return(View(cvm));
}
public async Task <IActionResult> Completed()
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
CompletedViewModel model = new CompletedViewModel(_repository.GetCompleted(new Guid(user.Id))
.Select(item => new TodoViewModel()
{
Title = item.Text, DateDue = item.DateDue, Id = item.Id, LinkText = "Remove from completed"
}).ToList());
return(View(model));
}
public ActionResult Completed()
{
CompletedViewModel vm = new CompletedViewModel();
using (TodoContext db = new TodoContext())
{
var AllTodos = db.Todos.OrderBy(x => x.CreateTime);
vm.CompletedList = AllTodos.Where(x => x.IsComplete == true).ToList();//完成的Todo
vm.NotCompleteCount = AllTodos.Where(x => x.IsComplete == false).Count();
}
return(View(vm));
}
public async Task <IActionResult> Completed()
{
Guid userId = new Guid(_userManager.GetUserId(User));
CompletedViewModel completed = new CompletedViewModel();
List <TodoItem> items = await _repository.GetCompletedAsync(userId);
foreach (var item in items)
{
TodoViewModel model = new TodoViewModel(item.Id, item.Text, item.DateCompleted, item.IsCompleted);
completed.Add(model);
}
return(View(completed));
}
public async Task <IActionResult> Completed()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
CompletedViewModel model = new CompletedViewModel(await _repository.GetCompleted(new Guid(user.Id)));
return(View(model));
}
public async Task <IActionResult> Completed()
{
ApplicationUser applicationUser = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> items = await _repository.GetCompleted(new Guid(applicationUser.Id));
//List<TodoItemLabel> labels = await _repository.getAllLabels();
List <TodoViewModel> destination = Mapper.Map <List <TodoItem>, List <TodoViewModel> >(items);
CompletedViewModel completedModel = new CompletedViewModel(destination);
return(View(completedModel));
}
public IActionResult Verified(Guid TurnID)
{
var t = _repository.GetTurn(TurnID);
var c = new CompletedViewModel {
Turn = t
};
_repository.CompleteTurn(t.ID);
_repository.SessionTurnID = null;
return(View(this.GetViewName("Completed"), c));
}
public IActionResult Completed()
{
Guid userId = new Guid(_userManager.GetUserId(User));
CompletedViewModel models = new CompletedViewModel();
List <TodoItem> items = _repository.GetCompleted(userId).OrderByDescending(i => i.DateCompleted).ToList();
foreach (TodoItem item in items)
{
TodoViewModel model = new TodoViewModel(item.Id, item.Text, item.DateCompleted, item.IsCompleted);
model.Labels = TodoViewModel.GetLabelsRaw(item.Labels);
models.Add(model);
}
return(View(models));
}
public async Task <IActionResult> Completed()
{
var todoItems = await _repository.GetCompleted(await GetUserId());
CompletedViewModel completedViewModel = new CompletedViewModel();
foreach (var td in todoItems)
{
TodoViewModel tdv = new TodoViewModel(td);
completedViewModel.TodoViewModels.Add(tdv);
}
return(View(completedViewModel));
}
public void And_Has_Ukprn_And_ValidationError_Then_Return_Provider_Completed_View(
CompletedViewModel model,
ReservationsRouteModel routeModel)
{
var controller = _fixture.Create <ReservationsController>();
controller.ModelState.AddModelError("AddApprentice", "AddApprentice");
var actual = controller.PostCompleted(routeModel, model);
var actualModel = actual as ViewResult;
Assert.IsNotNull(actualModel);
Assert.AreEqual(ViewNames.ProviderCompleted, actualModel.ViewName);
}
public async Task <IActionResult> GetCompleted()
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
var completedItems = await _todoRepository.GetCompletedAsync(new Guid(user.Id));
CompletedViewModel model = new CompletedViewModel();
foreach (TodoItem item in completedItems)
{
model.TodoViewModels.Add(new TodoViewModel(item));
}
return(View(model));
}
public async Task <IActionResult> Completed()
{
var user = await _user.GetUserAsync(HttpContext.User);
var golub = _repository.GetCompleted(new Guid(user.Id));
//List<TodoViewModel> todoViewModels = Mapper.Map<List<TodoItem>, List<TodoViewModel>>(golub);
List <TodoViewModel> todoViewModels = new List <TodoViewModel>();
foreach (var item in golub)
{
todoViewModels.Add(new TodoViewModel(item));
}
CompletedViewModel completedTodoModels = new CompletedViewModel(todoViewModels);
return(View(completedTodoModels));
}
public async Task <IActionResult> Completed()
{
ApplicationUser user = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> todoItems = _repository.GetCompleted(new Guid(user.Id));
List <TodoViewModel> todoViewModels = new List <TodoViewModel>();
foreach (var item in todoItems)
{
TodoViewModel viewModel = new TodoViewModel(item.Id, item.Text, item.DateCompleted);
todoViewModels.Add(viewModel);
}
CompletedViewModel indexViewModel = new CompletedViewModel(todoViewModels);
return(View(indexViewModel));
}
public ActionResult Checkout(CartViewModel cartViewModel, Entities.ComplexTypes.Cart cart)
{
var cartList = cart;
string cartListToJSON = Newtonsoft.Json.JsonConvert.SerializeObject(cartList);
string userName = User.Identity.Name;
int userId = GetUserIdByUserName(userName);
int shippingDetailId = GetShippingDetailId(cartViewModel);
int cartId = GetCartId(cartListToJSON);
int OrderDetailId = GetOrderDetailId(userId, shippingDetailId, cartId);
cart.Clear();
CompletedViewModel completedViewModel = new CompletedViewModel
{
UserName = User.Identity.Name,
OrderdetailId = OrderDetailId
};
return(RedirectToAction("Completed", "Cart", completedViewModel));
}
public async Task <ViewResult> Completed()
{
var currentUser = await _userManager.GetUserAsync(HttpContext.User);
var todoitems = _repository.GetCompleted(Guid.Parse(currentUser.Id)).OrderBy(t => t.DateDue);
var completedViewModel = new CompletedViewModel()
{
TodoViewModels = todoitems.Select(i => new TodoViewModel()
{
Id = i.Id.ToString(),
Text = i.Text,
DateCreated = i.DateCreated,
DateDue = i.DateDue,
DateCompleted = i.DateCompleted,
Labels = i.Labels
}).ToList()
};
return(View(completedViewModel));
}
public async Task <IActionResult> Completed()
{
var userId = await GetCurrentUserId();
var todos = new List <TodoViewModel>();
CompletedViewModel model = new CompletedViewModel();
foreach (var todo in _todoRepository.GetCompleted(userId))
{
todos.Add(new TodoViewModel()
{
Id = todo.Id,
Text = todo.Text,
Date = todo.DateCompleted,
IsCompleted = true
});
}
model.TodoItems = todos;
return(View(model));
}
protected override void OnAppearing()
{
_childPageLoaded = false;
init();
if (_currentSelected == null)
{
BindingContext = new CompletedViewModel(Navigation);
}
else
{
CompletedViewModel model = BindingContext as CompletedViewModel;
int selectedIndex = model.DeliveryOrders.IndexOf(_currentSelected);
InvoiceSQLite invoiceSQLite = App.InvoiceDatabase.GetInvoiceByInvoiceID(_currentSelected.InvoiceID);
if (!invoiceSQLite.CompletedDeliveryStatus)
{
model.DeliveryOrders.Remove(_currentSelected);
}
}
}
public IActionResult PostCompleted(ReservationsRouteModel routeModel, CompletedViewModel model)
{
if (!ModelState.IsValid)
{
var viewName = routeModel.UkPrn.HasValue ? ViewNames.ProviderCompleted : ViewNames.EmployerCompleted;
return(View(viewName, model));
}
switch (model.WhatsNext)
{
case CompletedReservationWhatsNext.RecruitAnApprentice:
var recruitUrl = routeModel.UkPrn.HasValue
? _urlHelper.GenerateUrl(new UrlParameters {
SubDomain = "recruit",
Id = routeModel.UkPrn.ToString()
})
: _urlHelper.GenerateUrl(new UrlParameters {
SubDomain = "recruit",
Folder = "accounts",
Id = routeModel.EmployerAccountId
});
return(Redirect(recruitUrl));
case CompletedReservationWhatsNext.FindApprenticeshipTraining:
return(Redirect(_configuration.FindApprenticeshipTrainingUrl));
case CompletedReservationWhatsNext.AddAnApprentice:
var addApprenticeUrl = _urlHelper.GenerateAddApprenticeUrl(routeModel.Id.Value,
routeModel.AccountLegalEntityPublicHashedId, model.CourseId, model.UkPrn, model.StartDate,
model.CohortRef, routeModel.EmployerAccountId, routeModel.UkPrn == null && model.UkPrn != null,
journeyData: model.JourneyData);
return(Redirect(addApprenticeUrl));
default:
var homeUrl = _urlHelper.GenerateDashboardUrl(routeModel.EmployerAccountId);
return(Redirect(homeUrl));
}
}
public async Task <IActionResult> Completed()
{
ApplicationUser currentUser = await _userManager.GetUserAsync(HttpContext.User);
List <TodoItem> todoItems = _repository.GetCompleted(new Guid(currentUser.Id));
List <TodoViewModel> todoViewModels = new List <TodoViewModel>();
CompletedViewModel completedViewModel = new CompletedViewModel();
foreach (TodoItem item in todoItems)
{
TodoViewModel model = new TodoViewModel();
model.Id = item.Id;
model.Labels = item.Labels;
model.Text = item.Text;
model.UserId = item.UserId;
model.DateCreated = item.DateCreated;
model.DateDue = item.DateDue;
model.DateCompleted = item.DateCompleted;
completedViewModel.Completed.Add(model);
}
return(View(completedViewModel));
}
