public PosViewModel(IRegionManager regionManager, IApplicationState applicationState, IApplicationStateSetter applicationStateSetter,
ITicketService ticketService, IUserService userService, ICacheService cacheService, TicketListViewModel ticketListViewModel,
TicketTagListViewModel ticketTagListViewModel, MenuItemSelectorViewModel menuItemSelectorViewModel, MenuItemSelectorView menuItemSelectorView,
TicketViewModel ticketViewModel, TicketOrdersViewModel ticketOrdersViewModel,TicketEntityListViewModel ticketEntityListViewModel)
{
_ticketService = ticketService;
_userService = userService;
_cacheService = cacheService;
_applicationState = applicationState;
_applicationStateSetter = applicationStateSetter;
_regionManager = regionManager;
_menuItemSelectorView = menuItemSelectorView;
_ticketViewModel = ticketViewModel;
_ticketOrdersViewModel = ticketOrdersViewModel;
_menuItemSelectorViewModel = menuItemSelectorViewModel;
_ticketListViewModel = ticketListViewModel;
_ticketTagListViewModel = ticketTagListViewModel;
_ticketEntityListViewModel = ticketEntityListViewModel;
EventServiceFactory.EventService.GetEvent<GenericEvent<Ticket>>().Subscribe(OnTicketEventReceived);
EventServiceFactory.EventService.GetEvent<GenericEvent<SelectedOrdersData>>().Subscribe(OnSelectedOrdersChanged);
EventServiceFactory.EventService.GetEvent<GenericEvent<EventAggregator>>().Subscribe(OnTicketEvent);
EventServiceFactory.EventService.GetEvent<GenericEvent<ScreenMenuItemData>>().Subscribe(OnMenuItemSelected);
EventServiceFactory.EventService.GetEvent<GenericIdEvent>().Subscribe(OnTicketIdPublished);
EventServiceFactory.EventService.GetEvent<GenericEvent<EntityOperationRequest<Entity>>>().Subscribe(OnEntitySelectedForTicket);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketTagGroup>>().Subscribe(OnTicketTagSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketStateData>>().Subscribe(OnTicketStateSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<Department>>().Subscribe(OnDepartmentChanged);
}
// Util
private TicketViewModel GetTicketModel(Ticket ticket)
{
var model = new TicketViewModel
{
Id = ticket.Id,
ServiceId = ticket.ServiceId,
ServiceName = ticket.Service.Name,
UserId = ticket.UserId,
PreOrder_Date = ticket.PreOrder_Date,
Price = ticket.Price,
IsUse = ticket.IsUse
};
return(model);
}
public async Task <IActionResult> Edit([FromBody] TicketViewModel ticketModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var ticket = _mapper.Map <TicketApiModel>(ticketModel);
ticket.LinkedTicketIds = ticketModel.LinkedTickets.Select(t => t.Id).ToList();
var ticketId = await _communicationService
.PutAsync($"user/teams/{ticketModel.TeamId}/tickets", ticket, FormHeaders(JsonType), "ticketapi");
return(Json(ticketId));
}
public IActionResult Index()
{
int userId = int.Parse(_userService.GetUserId(User));
var ticketServiceModels = _ticketService.GetAllTicketsForUser(userId);
var ticketTypesServiceModels = _nomenclatureService.GetTicketTypes();
var model = new TicketViewModel
{
UserTickets = _mapper.Map <List <UserTicketViewModel> >(ticketServiceModels),
TicketTypes = _mapper.Map <List <TicketTypeViewModel> >(ticketTypesServiceModels)
};
return(View(model));
}
public IActionResult Index()
{
List <Ticket> tickets = repo.GetAllTickets();
TicketViewModel vm = new TicketViewModel
{
Tickets = new List <TicketDetailViewModel>()
};
foreach (Ticket ticket in tickets)
{
vm.Tickets.Add(converter.TicketToViewModel(ticket));
}
return(View(vm.Tickets));
}
// GET: Tickets/Edit/5
public virtual ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TicketViewModel ticket = _db.Tickets.Find(id).ToTicketViewModel();
if (ticket == null)
{
return(HttpNotFound());
}
ViewBag.ProductId = new SelectList(_db.Products, "Id", "Name");
return(View(ticket));
}
public void Create(TicketViewModel ticketVM)
{
var Ticket = new Ticket
{
BillNo = billingVM.BillNo,
Date = billingVM.Date,
JobId = billingVM.JobId,
AccountId = billingVM.AccountId,
TypeId = billingVM.TypeId,
Amount = billingVM.Amount
};
unitOfWork.BillingRepository.Insert(Billing);
unitOfWork.Save();
}
public ActionResult Ticket(int id)
{
var ticket = _tickRepo.Get(id);
var reservation = _reservationRepo.Get(ticket.ReservationId);
var placeInRun = _runRepo.GetPlaceInRun(reservation.PlaceInRunId);
var ticketWM = new TicketViewModel();
ticketWM.Ticket = ticket;
ticketWM.PlaceNumber = placeInRun.Number;
ticketWM.Date = placeInRun.Run.Date;
ticketWM.Train = _trainRepo.GetTrainDetails(placeInRun.Run.TrainId);
return(View(ticketWM));
}
public IActionResult CreateTicket(TicketViewModel newTicket)
{
if (!_isLoggedIn)
{
return(RedirectToAction("Index"));
}
if (ModelState.IsValid)
{
User ticketCreator = dbContext.Users.FirstOrDefault(u => u.UserId == _uid);
Admin Creator = dbContext.Admins.FirstOrDefault(a => a.AdminId == _uid);
User AssignedUser = dbContext.Users.FirstOrDefault(u => u.UserId == newTicket.Ticket.UserId);
if (ticketCreator.UserPrivilage == 1)
{
if (newTicket.Ticket.Deadline > DateTime.Now)
{
newTicket.Ticket.AssignedUser = AssignedUser;
newTicket.Ticket.Creator = Creator;
newTicket.Ticket.Creator.UserId = ticketCreator.UserId;
dbContext.Add(newTicket.Ticket);
dbContext.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
ModelState.AddModelError("Ticket.Deadline", "Deadling must be set in to the future");
List <User> allUsers = dbContext.Users.ToList();
return(View("NewTicket", new TicketViewModel {
Users = allUsers
}));
}
}
else
{
ModelState.AddModelError("Ticket.UserId", "Need amin privileges to create/assign a new ticket");
List <User> allUsers = dbContext.Users.ToList();
return(View("NewTicket", new TicketViewModel {
Users = allUsers
}));
}
}
else
{
List <User> allUsers = dbContext.Users.ToList();
return(View("NewTicket", new TicketViewModel {
Users = allUsers
}));
}
}
public TicketViewModel GetTicketDetails(int projectionId)
{
var projection = this.projectionsRepository.All().FirstOrDefault(x => x.Id == projectionId);
if (projection == null)
{
return(null);
}
var hallId = projection.HallId;
var hall = this.hallRepository.All().FirstOrDefault(x => x.Id == hallId);
var viewModel = new TicketViewModel
{
ProjectionId = projectionId,
MovieId = projection.MovieId,
Rows = this.rowsList,
SeatNumbers = this.seatsNumbers,
};
var prices = new List <TicketByPriceModel>()
{
new TicketByPriceModel
{
Type = TicketType.Regular,
Price = 10,
},
new TicketByPriceModel
{
Type = TicketType.Children,
Price = 8.50m,
},
new TicketByPriceModel
{
Type = TicketType.Adult,
Price = 9,
},
};
var occupiedSeats = this.seatRepository.All()
.Where(x => x.ProjectionId == viewModel.ProjectionId && x.IsOccupied == true)
.OrderBy(x => x.Row).ThenBy(x => x.SeatNumer)
.ToList();
viewModel.OccupiedSeats = occupiedSeats;
viewModel.TicketPrice = prices;
return(viewModel);
}
public List <TicketViewModel> GetList()
{
List <Ticket> tickets = context.Tickets.ToList();
var result = new List <TicketViewModel>();
foreach (Ticket line in tickets)
{
TicketViewModel model = config.CreateMapper().Map <Ticket, TicketViewModel>(line);
model.Asset = new Asset();
model.Asset.AccountName = line.AccountTickets.Select(x => x.Account.AccountName).Single();
model.Asset.Hostname = line.DeviceTickets.Select(x => x.Device.Hostname).Single();
model.Asset.Domain = line.DeviceTickets.Select(x => x.Device.Domain).Single();
result.Add(model);
}
return(result);
}
public TicketViewModel ViewModelFromDataModel(Ticket ticket)
{
var ticketView = new TicketViewModel();
ticketView.Id = ticket.Id;
ticketView.Title = ticket.Title;
ticketView.Description = ticket.Description;
ticketView.Created = ticket.Created;
ticketView.Updated = ticket.Updated;
ticketView.ProjectName = db.Projects.Find(ticket.ProjectId).Name;
ticketView.TicketTypeName = db.TicketTypes.Find(ticket.TicketTypeId).Name;
ticketView.TicketPriorityName = db.TicketPriorities.Find(ticket.TicketPriorityId).Name;
ticketView.TicketStatusName = db.TicketStatus.Find(ticket.TicketStatusId).Name;
ticketView.OwnerUserName = db.Users.Find(ticket.OwnerUserId).UserName;
ticketView.AssignedToUserName = db.Users.Find(ticket.AssignedToUserId).UserName;
return ticketView;
}
private void SetList(List <RouteStation> routeStations, TicketViewModel model)
{
foreach (var routeStation in routeStations)
{
var trip = context.Trips.FirstOrDefault(t => t.Date == model.Date && t.Route == routeStation.Route);
if (trip == null)
{
var wagonRoutes = context.Routes.Include(rt => rt.WagonRoutes).ThenInclude(wr => wr.Wagon).ToList();
//foreach(var wagonRoute in wagonRoutes)
//{
// from wr in wagonRoute.WagonRoutes
// join w in context.Wagons on wr.Wagon.Id equals w.
//}
}
}
}
public IActionResult Edit(int id)
{
var ticket = _dbContext.Tickets.Single(t => t.Id == id);
var viewModel = new TicketViewModel
{
StatusId = ticket.StatusId,
Title = ticket.Title,
Id = ticket.Id,
DateCreated = ticket.DateCreated,
SitNumber = ticket.SitNumber,
Description = ticket.Description
};
return(View(viewModel));
}
public ActionResult AddTicket(string spacename, TicketViewModel ticketViewModel)
{
if (ModelState.IsValid)
{
var savedSuccessfully = repo.AddTicket(spacename, ticketViewModel);
if (savedSuccessfully)
{
return(RedirectToAction("Cardwall", "Space", new { spacename = spacename }));
}
else
{
return(RedirectToAction("Error"));
}
}
return(View(ticketViewModel));
}
public ActionResult CreateTicket(Ticket Ticket)
{
if (!ModelState.IsValid)
{
var ticketViewModel = new TicketViewModel
{
Priorities = DapperORM.GetPriority(),
Projects = DapperORM.GetProjectsForReportABug(),
Ticket = Ticket
};
return(View("ReportABug", ticketViewModel));
}
DapperORM.saveTicket(Ticket);
return(RedirectToAction("MyTickets", "User", new { id = username }));
}
public async Task <ActionResult> Edit(string id)
{
if (ModelState.IsValid)
{
var ticket = await _ticketService.Get(ObjectId.Parse(id));
ticket.IdString = ticket.Id.ToString();
var model = new TicketViewModel
{
Ticket = ticket
};
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(int id, TicketViewModel ticketViewModel)
{
if (id != ticketViewModel.Id)
{
return(NotFound());
}
var ticket = await _context.Tickets.FirstOrDefaultAsync(t => t.Id == id);
Status status = _context.Statussen.OrderBy(s => s.Volgorde).FirstOrDefault();
bool modelStatus = !string.IsNullOrEmpty(ticketViewModel.Omschrijving) && ticketViewModel.StatusId != status.Id;
if (modelStatus == false)
{
return(Redirect("~/Tickets/Edit/" + id));
}
if (ModelState.IsValid && modelStatus)
{
try
{
ticket.Omschrijving = ticketViewModel.Omschrijving;
ticket.StatusId = ticketViewModel.StatusId;
_context.Update(ticket);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TicketExists(ticket.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewBag.Klant = ticket.Klant.VolledigeNaam;
ViewBag.Applicatie = ticket.Applicatie.Naam;
ViewBag.Datum = ticket.Datum.ToShortDateString();
ViewBag.Onderwerp = ticket.Onderwerp;
ViewData["StatusId"] = new SelectList(_context.Statussen, "Id", "Naam", ticket.StatusId);
return(View(ticketViewModel));
}
// GET: Tickets/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var tickets = await _context.Tickets
.Include(t => t.Contact)
.Include(t => t.Contract)
.Include(t => t.TicketImpact)
.Include(t => t.TicketType)
.Include(t => t.TicketUrgency)
.FirstOrDefaultAsync(m => m.Id == id);
if (tickets == null)
{
return(NotFound());
}
var assignetToUsername = await _userContext.Users
.FirstOrDefaultAsync(u => u.Id == tickets.AssignedTo);
var createdByUsername = await _userContext.Users
.FirstOrDefaultAsync(u => u.Id == tickets.CreatedBy);
var ticketViewModel = new TicketViewModel
{
Ticket = tickets,
AssignedToUsername = assignetToUsername.UserName,
CreatedByUsername = createdByUsername.UserName
//Status = new SelectList(await statusQuery.Distinct().ToListAsync()),
//Accounts = new SelectList(await clientsQuery.Distinct().ToListAsync()),
//Contracts = await contractsResults.ToListAsync()
};
ViewData["ContactId"] = new SelectList(_context.Contacts, "Id", "Email", tickets.ContactId);
ViewData["ContractId"] = new SelectList(_context.Contracts, "Id", "Name", tickets.ContractId);
ViewData["TicketImpactId"] = new SelectList(_context.TicketImpacts, "Id", "Name", tickets.TicketImpactId);
ViewData["TicketTypeId"] = new SelectList(_context.TicketTypes, "Id", "Name", tickets.TicketTypeId);
ViewData["TicketUrgencyId"] = new SelectList(_context.TicketUrgencies, "Id", "Name", tickets.TicketUrgencyId);
ViewData["AssignedTo"] = new SelectList(_userContext.Users, "Id", "Username", tickets.AssignedTo);
ViewData["CreatedBy"] = new SelectList(_userContext.Users, "Id", "Username", tickets.CreatedBy);
return(View(ticketViewModel));
}
public ActionResult ReserveSeats(string ticket, TicketViewModel ticketViewModel)
{
TicketViewModel viewModel;
try
{
viewModel = JsonConvert.DeserializeObject <TicketViewModel>(ticket);
}
catch
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wystąpił nieoczekiwany błąd."
}));
}
if (viewModel == null)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wystąpił nieoczekiwany błąd."
}));
}
viewModel.SeatsChoose = ticketViewModel.SeatsChoose;
if (viewModel.SeatsChoose.Count != viewModel.Count)
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Wybrano niepoprawną liczbę miejsc."
}));
}
using (IEasyTrainTicketsDbEntities dbContext = unitOfFactory.CreateUnitOfWork())
{
if (!buyTicketModel.NextPart(viewModel, dbContext))
{
return(View("MyError", new ErrorViewModel()
{
ErrorMessage = "Z przykrością informujemy, że nie ma wystarczającej ilości miejsc w wybranym połączeniu"
}));
}
}
ModelState.Clear();
if (buyTicketModel.IsEnd(viewModel))
{
return(View("SummaryReservation", viewModel));
}
return(View(viewModel));
}
public IActionResult EditTicketAdmin(int id, TicketViewModel updateTicket)
{
if (!_isLoggedIn)
{
return(RedirectToAction("Index"));
}
if (ModelState.IsValid)
{
if (updateTicket.Ticket.Deadline > DateTime.Now)
{
Ticket thisTicket = dbContext.Tickets.FirstOrDefault(ticket => ticket.TicketId == id);
User assignedUser = dbContext.Users.FirstOrDefault(user => user.UserId == updateTicket.UserId);
User ticketCreator = dbContext.Users.FirstOrDefault(user => user.UserId == _uid);
Admin Creator = dbContext.Admins.FirstOrDefault(admin => admin.AdminId == _uid);
thisTicket.Title = updateTicket.Ticket.Title;
thisTicket.Description = updateTicket.Ticket.Description;
thisTicket.Priority = updateTicket.Ticket.Priority;
thisTicket.Deadline = updateTicket.Ticket.Deadline;
thisTicket.Status = updateTicket.Ticket.Status;
thisTicket.UserId = updateTicket.Ticket.UserId;
thisTicket.Creator = Creator;
thisTicket.Creator.UserId = ticketCreator.UserId;
thisTicket.AssignedUser = assignedUser;
thisTicket.UpdatedAt = DateTime.Now;
dbContext.Update(thisTicket);
dbContext.SaveChanges();
return(RedirectToAction("Dashboard"));
}
else
{
ModelState.AddModelError("Ticket.Deadline", "Deadline must be set to a future date.");
Ticket thisTicket = dbContext.Tickets.Include(ticket => ticket.AssignedUser).FirstOrDefault(ticket => ticket.TicketId == id);
List <User> allUsers = dbContext.Users.ToList();
return(RedirectToAction("EditTicket", new TicketViewModel {
Ticket = thisTicket, Users = allUsers
}));
}
}
Ticket thiseditTicket = dbContext.Tickets.Include(ticket => ticket.AssignedUser).FirstOrDefault(ticket => ticket.TicketId == id);
List <User> alleditUsers = dbContext.Users.ToList();
return(RedirectToAction("EditTicket", new TicketViewModel {
Ticket = thiseditTicket, Users = alleditUsers
}));
}
public async Task <ActionResult> AuditTicket(TicketViewModel model)
{
if (string.IsNullOrWhiteSpace(SessionVar.GetString("displayName")))
{
Redirect("~/Account/Login");
}
if (!HomeController.IsMember(User.Identity.Name, ConfigurationManager.AppSettings["ADIAG"].ToString()))
{
Redirect("~/Account/AccessDenied");
}
if (string.IsNullOrWhiteSpace(model.Description))
{
return(Json(new { type = "danger", header = "Error", message = "Please enter a note for your action." }));
}
StringBuilder errors = new StringBuilder();
Guid id = model.TicketID;
var isTicketUpdated = await IsTicketUpdated(model);
if (isTicketUpdated.Item1)
{
GeneralSetting generalSetting = null;
using (HelpDeskEntities dataContext = new HelpDeskEntities())
{
generalSetting = await dataContext.GeneralSettings.FirstOrDefaultAsync();
if (generalSetting != null)
{
Ticket ticket = await dataContext.Tickets.FirstOrDefaultAsync(param => param.TicketID == model.TicketID);
if (ticket != null)
{
// mail sender and ict
string recipients = ticket.OwnerEmail + "," + generalSetting.RecipientEmails;
SendEmail("ICT HelpDesk Re: [" + model.TicketNo + "] " + model.Subject, model.Description, recipients, id.ToString(), model.FileAttachments);
}
}
}
return(Json(new { type = "success", header = "Success", message = "" }));
}
return(Json(new { type = "danger", header = "Error", message = isTicketUpdated.Item2 }));
}
public static TicketViewModel CreateTicketViewModel(TicketListingServiceModel serviceTicket)
{
var model = new TicketViewModel
{
Id = serviceTicket.Id,
PostTime = serviceTicket.PostTime,
Project = serviceTicket.Project,
Sender = serviceTicket.Sender,
TicketType = (WEB_ENUMS.TicketType)Enum.Parse(typeof(WEB_ENUMS.TicketType), serviceTicket.TicketType.ToString()),
TicketState = (WEB_ENUMS.TicketState)Enum.Parse(typeof(WEB_ENUMS.TicketState), serviceTicket.TicketState.ToString()),
Title = serviceTicket.Title,
Description = serviceTicket.Description,
AttachedFiles = serviceTicket.AttachedFiles
};
return(model);
}
public ActionResult Create(int?id)
{
if (id == null)
{
return(View(new TicketViewModel()));
}
DetectionRepository detectRepo = new DetectionRepository();
DetectionEditViewModel detect = detectRepo.Get(id);
var model = new TicketViewModel();
model.Asset = detect.Asset;
model.DetectionId = detect.DetectionId.ToString();
model.AssociatedEventCount = detect.AssociatedEventCount;
return(View(model));
}
public async Task <ActionResult> Edit(TicketViewModel model)
{
if (ModelState.IsValid)
{
try
{
await repo.Update(model);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError(String.Empty, e.Message);
}
}
return(View(model));
}
// GET: Tickets/Create
public async Task <IActionResult> Create(int?id)
{
var x = new TicketViewModel
{
Screening = await _context.Screening
.Include(m => m.Salon)
.Include(m => m.Movie)
.Include(m => m.Tickets)
.FirstOrDefaultAsync(m => m.ScreeningID == id)
};
if (x.Screening != null && x.Screening.FreeSeats > 0)
{
return(View(x));
}
return(NotFound());
}
// GET /ticket/close/{id}
public IActionResult Close(int id)
{
// retrieve ticket via service
var t = svc.GetTicket(id);
if (t == null)
{
return(NotFound());
}
var tvm = new TicketViewModel {
Id = t.Id, StudentId = t.StudentId, Issue = t.Issue
};
// redirect to the index view
return(View(tvm));
}
public async Task Update_NotFound_WhenNoTicketWithId()
{
var updatedTicket = new TicketViewModel()
{
Id = "NONE",
Name = "NEWNAME",
ProjectName = projName1,
VideoFiles = null
};
var response = await _httpClient.PostAsync("/api/tickets/NONE",
new StringContent(
JsonConvert.SerializeObject(updatedTicket),
Encoding.UTF8,
"application/json"));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public IActionResult Edit(TicketViewModel model)
{
this.ViewData[GlobalConstants.Statuses] = this.statusesService.GetAllStatuses();
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var ticket = this.ticketsService.UpdateTicket(model);
if (ticket == null)
{
return(this.View(model));
}
return(this.RedirectToAction(nameof(Index)));
}
void EditTicket(object parameter)
{
if (!ValidateParams(parameter))
{
ShowInfoWindow("Podaj poprawne dane");
return;
}
var values = (object[])parameter;
int matchTicketID = Int32.Parse(values[0].ToString());
string PESEL = values[1].ToString();
TicketViewModel currentTicket = (TicketViewModel)values[2];
if (ticketService.EditTicket(matchTicketID, PESEL, currentTicket.ID))
{
RefereshAll();
}
}
public ActionResult Create(int?id)
{
int applicatieId = 0;
if (id != null)
{
Applicatie applicatie = db.Applicaties.Find(id);
applicatieId = applicatie.Id;
}
TicketViewModel ticketView = new TicketViewModel
{
ApplicatieId = applicatieId,
Applicaties = db.Applicaties.ToList()
};
return(View(ticketView));
}
// GET: Tickets/Delete/5
public ActionResult Delete(int projectId, int?id)
{
ViewBag.ProjectId = projectId;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Ticket ticket = db.Tickets.Where(t => t.ProjectID == projectId).FirstOrDefault(t => t.ID == id);
TicketViewModel model = new TicketViewModel(ticket);
if (ticket == null)
{
return(HttpNotFound());
}
return(View(model));
}
public static TicketDomain Create(TicketViewModel ticket)
{
return new TicketDomain
{
Id = ticket.Id,
Title = ticket.Title,
Description = ticket.Description,
AgentReply = ticket.AgentReply,
AssignedAgent = ticket.AssignedAgent,
Owner = ticket.Owner,
OwnerId = ticket.OwnerId,
AssignedAgentId = ticket.AssignedAgentId,
TicketState = ticket.TicketState,
TicketPriority = ticket.TicketPriority,
ProductId = ticket.ProductId,
Product = ticket.Product
};
}
public PosViewModel(IRegionManager regionManager, IApplicationState applicationState, IApplicationStateSetter applicationStateSetter,
ITicketService ticketService, ITicketServiceBase ticketServiceBase, IUserService userService, ICacheService cacheService, IMessagingService messagingService,
TicketListViewModel ticketListViewModel, TicketTagListViewModel ticketTagListViewModel, MenuItemSelectorViewModel menuItemSelectorViewModel,
MenuItemSelectorView menuItemSelectorView, TicketViewModel ticketViewModel, TicketOrdersViewModel ticketOrdersViewModel,
TicketEntityListViewModel ticketEntityListViewModel, TicketTypeListViewModel ticketTypeListViewModel, AccountBalances accountBalances)
{
_ticketService = ticketService;
_ticketServiceBase = ticketServiceBase;
_userService = userService;
_cacheService = cacheService;
_messagingService = messagingService;
_applicationState = applicationState;
_applicationStateSetter = applicationStateSetter;
_regionManager = regionManager;
_menuItemSelectorView = menuItemSelectorView;
_ticketViewModel = ticketViewModel;
_ticketOrdersViewModel = ticketOrdersViewModel;
_menuItemSelectorViewModel = menuItemSelectorViewModel;
_ticketListViewModel = ticketListViewModel;
_ticketTagListViewModel = ticketTagListViewModel;
_ticketEntityListViewModel = ticketEntityListViewModel;
_ticketTypeListViewModel = ticketTypeListViewModel;
_accountBalances = accountBalances;
EventServiceFactory.EventService.GetEvent<GenericEvent<Order>>().Subscribe(OnOrderEventReceived);
EventServiceFactory.EventService.GetEvent<GenericEvent<Ticket>>().Subscribe(OnTicketEventReceived);
EventServiceFactory.EventService.GetEvent<GenericEvent<EventAggregator>>().Subscribe(OnTicketEvent);
EventServiceFactory.EventService.GetEvent<GenericEvent<ScreenMenuItemData>>().Subscribe(OnMenuItemSelected);
EventServiceFactory.EventService.GetEvent<GenericIdEvent>().Subscribe(OnTicketIdPublished);
EventServiceFactory.EventService.GetEvent<GenericEvent<OperationRequest<Entity>>>().Subscribe(OnEntitySelectedForTicket);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketTagGroup>>().Subscribe(OnTicketTagSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketStateData>>().Subscribe(OnTicketStateSelected);
EventServiceFactory.EventService.GetEvent<GenericEvent<TicketType>>().Subscribe(OnTicketTypeChanged);
EventServiceFactory.EventService.GetEvent<GenericEvent<EventAggregator>>().Subscribe(
x =>
{
if (x.Topic == EventTopicNames.ResetCache && _applicationState.CurrentTicketType != null)
{
_menuItemSelectorViewModel.Reset();
_menuItemSelectorViewModel.UpdateCurrentScreenMenu(_applicationState.CurrentTicketType.GetScreenMenuId(_applicationState.CurrentTerminal));
}
});
}
private void OnMoveOrders(string obj)
{
SelectedTicket.FixSelectedItems();
var newTicketId = _ticketService.MoveOrders(SelectedTicket.Model, SelectedTicket.SelectedOrders.Select(x => x.Model), 0).TicketId;
_selectedTicket = null;
_selectedOrders.Clear();
OpenTicket(newTicketId);
EventServiceFactory.EventService.PublishEvent(EventTopicNames.ActivateTicket);
RefreshVisuals();
SelectedTicket.ClearSelectedItems();
SelectedTicket.PublishEvent(EventTopicNames.TicketDisplayed);
}
private void CloseTicket()
{
if (_applicationState.CurrentDepartment.IsFastFood && !CanCloseTicket(""))
{
SaveTicketIfNew();
RefreshVisuals();
return;
}
if (!CanCloseTicket("")) return;
if (SelectedTicket.Orders.Count > 0 && SelectedTicket.Model.GetRemainingAmount() == 0)
{
var message = SelectedTicket.GetPrintError();
if (!string.IsNullOrEmpty(message))
{
SelectedTicket.ClearSelectedItems();
RefreshVisuals();
InteractionService.UserIntraction.GiveFeedback(message);
return;
}
}
SelectedTicket.ClearSelectedItems();
var result = _ticketService.CloseTicket(SelectedTicket.Model);
if (!string.IsNullOrEmpty(result.ErrorMessage))
{
InteractionService.UserIntraction.GiveFeedback(result.ErrorMessage);
}
_selectedTicket = null;
_selectedOrders.Clear();
if (_applicationState.CurrentTerminal.AutoLogout)
{
_userService.LogoutUser(false);
}
else EventServiceFactory.EventService.PublishEvent(EventTopicNames.ActivatePosView);
AppServices.MessagingService.SendMessage(Messages.TicketRefreshMessage, result.TicketId.ToString());
_applicationStateSetter.SetApplicationLocked(false);
}
private void OpenTicket(int id)
{
_applicationStateSetter.SetApplicationLocked(true);
var ticket = _ticketService.OpenTicket(id);
SelectedTicket = new TicketViewModel(ticket,
_applicationState.CurrentDepartment.TicketTemplate,
_applicationState.CurrentDepartment != null && _applicationState.CurrentDepartment.IsFastFood,
_ticketService, _automationService, _applicationState);
Totals.Model = ticket ?? Ticket.Empty;
if (_applicationState.CurrentDepartment != null)
PaymentButtonGroup.UpdatePaymentButtons(_applicationState.CurrentDepartment.TicketTemplate.PaymentTemplates.Where(x => x.DisplayUnderTicket));
}
// GET: Tickets/Edit/5
public ActionResult Edit(int? id, bool? projectReturn)
{
if (id == null)
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
Ticket ticket = db.Tickets
.Include(t => t.Project.Authorizations)
.First(t => t.Id == id);
var auths = ticket.Project.Authorizations
.Where(auth => auth.User_ID == User.Identity.GetUserId());
if (!auths.Any(auth => auth.Permission == Permission.Administrator))
{
bool isSubmitter = auths.Any(auth =>
auth.Permission == Permission.Submitter)
&& ticket.Submitter.Id == User.Identity.GetUserId();
if(!isSubmitter)
{
return new HttpStatusCodeResult(HttpStatusCode.Forbidden,
"You do not have sufficient permissions for that resource.");
}
}
TicketViewModel model = new TicketViewModel(ticket, db.Tags);
if(projectReturn.HasValue)
model.Project_Redirect = projectReturn.Value;
return View(model);
}
