public Task <bool> Handle(RegisterTicketCommand message, CancellationToken cancellationToken)
{
var ticket = new Ticket(message.Id, message.Description, message.Localization, message.TicketStatusId, message.TicketTypeId, message.DateRegister);
if (!TicketIsValid(ticket))
{
return(Task.FromResult(false));
}
var ticketRegistred = _ticketRepository.Find(c => c.Id == ticket.Id);
if (ticketRegistred.Any())
{
_mediator.PublishEvent(new DomainNotification(message.MessageType, "Já existe um ticket com esse Id"));
}
_ticketRepository.Add(ticket);
if (Commit())
{
_mediator.PublishEvent(new TicketRegisteredEvent(ticket.Id, ticket.Description, ticket.Localization, ticket.TicketStatusId, ticket.TicketTypeId, ticket.DateRegister));
}
return(Task.FromResult(true));
}
public void Listen(string json)
{
var ticket = ConvertToTicket(json);
ticket.Protocol = GenerateProtocol();
_ticketRepository.Add(ticket);
}
public IActionResult Create(TicketViewModel ticketViewModel)
{
if (ModelState.IsValid)
{
string gebruikersnaam = User.Identity.Name;
Gebruiker gebruiker = _gebruikerRepository.GetByGebruikersnaamKlant(gebruikersnaam);
try
{
Gebruiker technieker = _gebruikerRepository.GetByGebruikersnaamTechnieker(ticketViewModel.Technieker);
Ticket ticket = new Ticket(ticketViewModel.Titel, ticketViewModel.Omschrijving, gebruiker);
MapTicketViewModelToTicket(ticketViewModel, ticket);
_ticketRepository.Add(ticket);
_ticketRepository.SaveChanges();
TempData["message"] = $" {ticket.Titel} is aangemaakt.";
}
catch
{
TempData["error"] = "Er is iets misgelopen bij het aanmaken van een ticket";
}
return(RedirectToAction(nameof(Index)));
}
//ViewData["Techniekers"] = GetTechniekersAsSelectedList();
return(View(nameof(Edit)));
}
public async Task <IActionResult> CreateComment(CommentForCreationDto commentForCreationDto)
{
// if (creator.Id != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
// return Unauthorized();
var comment = _mapper.Map <Comment>(commentForCreationDto);
comment.UserId = Int32.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var regexItem = new Regex("^[a-zA-Z0-9 ]*$");
if (!regexItem.IsMatch(comment.Description))
{
throw new Exception("Description invalid");
}
_repo.Add(comment);
if (await _repo.SaveAll())
{
var commentToReturn = _mapper.Map <CommentForReturnDto>(comment);
//commentToReturn.UserName = comment.User.Username;
return(CreatedAtRoute("GetComment",
new { comment.TicketId, id = comment.Id }, commentToReturn));
}
throw new Exception("Creating the comment failed on save");
}
public async Task <IActionResult> CreateTicket(TicketForCreationDto ticketForCreationDto)
{
var ticket = _mapper.Map <Ticket>(ticketForCreationDto);
ticket.UserId = Int32.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
//ticket.Description = Regex.Replace(ticket.Description, "[^0-9A-Za-z]+", " ");
var regexItem = new Regex("^[a-zA-Z0-9 ]*$");
if (!regexItem.IsMatch(ticket.Description))
{
throw new Exception("Description invalid");
}
_repo.Add(ticket);
if (await _repo.SaveAll())
{
var ticketToReturn = _mapper.Map <TicketForListDto>(ticket);
ticketToReturn.UserName = User.Identity.Name;
ticketToReturn.TicketNumber = ticket.Id;
return(CreatedAtRoute("GetTicket",
new { id = ticket.Id }, ticketToReturn));
}
throw new Exception("Creating the message failed on save");
}
public long Add(TicketAddCommand ticket)
{
var ticketAdd = Mapper.Map <TicketAddCommand, Ticket>(ticket);
ticketAdd.DateBuy = DateTime.Now;
var session = SessionRepository.GetById(ticket.SessionId);
ticketAdd.Session = session;
var movie = MovieRepository.GetById(ticket.MovieId);
ticketAdd.Movie = movie;
var user = UserRepository.GetById(ticket.UserId);
ticketAdd.User = user;
var snacks = SnackRepository.GetById(ticket.SnacksIds);
ticketAdd.Snacks = snacks;
var movieTheater = MovieTheaterRepository.GetById(ticket.MovieTheaterId);
ticketAdd.MovieTheater = movieTheater;
var newTicket = TicketRepository.Add(ticketAdd);
return(newTicket.Id);
}
public async Task <TicketDTO> Handle(CreateTicketCommand message, CancellationToken cancellationToken)
{
var seat = _seatingRepository.GetAsync(message.SeatId);
if (seat == null)
{
throw new ArgumentNullException(nameof(seat));
}
if (seat.Result.IsOccupied)
{
throw new TicketingDomainException("Seat is already occupied");
}
var customer = _customerRepository.GetAsync(message.SeatId);
if (seat == null)
{
throw new ArgumentNullException(nameof(seat));
}
var ticket = new Ticket(message.SeatId, message.CustomerId);
Log.Information($"Creating Ticket: {ticket}");
_ticketRepository.Add(ticket);
await _ticketRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
var result = new TicketDTO()
{
TicketId = ticket.Id,
CreatedOn = Timestamp.FromDateTime(ticket.CreatedOn)
};
return(await Task.FromResult(result));
}
public Ticket Create(Ticket ticket)
{
if (ticket == null)
{
throw new Exception("The object is not valid");
}
return(ticketRepository.Add(ticket));
}
public async Task <int> Add(TicketModel ticketiewmodels)
{
ticketiewmodels.TikEstado = 0;
ticketiewmodels.TikFechaRegistro = DateTime.Now;
var addEntity = await _ticketRepository.Add(TicketMapper.Map(ticketiewmodels));
return(addEntity);
}
public ActionResult PurchaseTickets(string tenant, string eventId, string customerId, string ticketPrice, string ticketCount, string sectionId)
{
bool purchaseResult = false;
int numberOfTickets = Convert.ToInt32(ticketCount);
if (string.IsNullOrEmpty(eventId) || string.IsNullOrEmpty(customerId) || string.IsNullOrEmpty(ticketPrice) || string.IsNullOrEmpty(ticketCount))
{
var message = _localizer["Enter quantity"];
DisplayMessage(message, "Confirmation");
return(RedirectToAction("Index", "Events", new { tenant = Startup.TenantConfig.TenantName }));
}
var ticketPurchaseModel = new TicketPurchaseModel
{
CustomerId = Convert.ToInt32(customerId),
PurchaseTotal = Convert.ToDecimal(ticketPrice)
};
SetTenantConfig(tenant);
var latestPurchaseTicketId = _iTicketPurchaseRepository.GetNumberOfTicketPurchases(_connectionString, Startup.TenantConfig.TenantId);
ticketPurchaseModel.TicketPurchaseId = latestPurchaseTicketId + 1;
var purchaseTicketId = _iTicketPurchaseRepository.Add(ticketPurchaseModel, _connectionString, Startup.TenantConfig.TenantId);
var ticketModel = new TicketModel
{
SectionId = Convert.ToInt32(sectionId),
EventId = Convert.ToInt32(eventId),
TicketPurchaseId = purchaseTicketId
};
Random rnd = new Random();
for (var i = 0; i < numberOfTickets; i++)
{
Random rnd2 = new Random(5000);
ticketModel.RowNumber = rnd.Next(0, 100000);
ticketModel.SeatNumber = rnd2.Next(0, 100000);
purchaseResult = _ticketRepository.Add(ticketModel, _connectionString, Startup.TenantConfig.TenantId);
}
var successMessage = _localizer[$"You have successfully purchased {ticketCount} tickets."];
var failureMessage = _localizer["Failed to purchase tickets."];
if (purchaseResult)
{
DisplayMessage(successMessage, "Confirmation");
}
else
{
DisplayMessage(failureMessage, "Error");
}
return(RedirectToAction("Index", "Events", new { tenant = Startup.TenantConfig.TenantName }));
}
public int PostTicket(string username, TicketPostViewModel model)
{
var customerId = _customerRepository.Get(x => x.Username == username && x.Deleted == false).Id;
var existedTicket = _ticketRepository.Get(x => x.TicketCode.ToLower().Equals(model.TicketCode.ToLower()) &&
x.TransportationId == model.TransportationId && x.TicketTypeId == model.TicketTypeId &&
x.DepartureStationId == model.DepartureStationId && x.ArrivalStationId == model.ArrivalStationId &&
DateTime.Equals(x.DepartureDateTime, model.DepartureDateTime) && DateTime.Equals(x.ArrivalDateTime, model.ArrivalDateTime));
if (existedTicket != null && existedTicket.Status != TicketStatus.Invalid)
{
throw new InvalidOperationException();
}
var ticket = _mapper.Map <TicketPostViewModel, Ticket>(model);
ticket.CommissionPercent = 10;
ticket.Status = Core.Enum.TicketStatus.Pending;
ticket.SellerId = customerId;
ticket.ExpiredDateTime = model.DepartureDateTime;
//convert time into UTC time
var departureStation = _stationRepository.Get(x => x.Id == ticket.DepartureStationId && x.Deleted == false);
if (departureStation.City.TimeZoneId != null)
{
ticket.DepartureDateTimeUTC = ticket.DepartureDateTime.ToSpecifiedTimeZone(departureStation.City.TimeZoneId);
if (ticket.ExpiredDateTime != null)
{
ticket.ExpiredDateTimeUTC = ticket.ExpiredDateTime.Value.ToSpecifiedTimeZone(departureStation.City.TimeZoneId);
}
}
else
{
ticket.DepartureDateTimeUTC = ticket.DepartureDateTime;
ticket.ExpiredDateTimeUTC = ticket.ExpiredDateTime;
}
var arrivalStation = _stationRepository.Get(x => x.Id == ticket.ArrivalStationId && x.Deleted == false);
if (arrivalStation.City.TimeZoneId != null)
{
ticket.ArrivalDateTimeUTC = ticket.ArrivalDateTime.ToSpecifiedTimeZone(arrivalStation.City.TimeZoneId);
}
else
{
ticket.ArrivalDateTimeUTC = ticket.ArrivalDateTime;
}
_ticketRepository.Add(ticket);
_unitOfWork.CommitChanges();
//noti to staff
List <string> adminDeviceIds = GetAdminDeviceIds();
var message = "A new ticket is posted";
_oneSignalService.PushNotificationAdmin(message, adminDeviceIds);
return(ticket.Id);
}
public Task Handle(TicketScanStartedNotification notification, CancellationToken cancellationToken)
{
var seat = new SeatModel(notification.Seat.Number, notification.Seat.Letter);
_ticketRepository.Add(new TicketScanModel(notification.Identifier, seat));
_eventAggregator.Publish(new TicketScanAdded(notification.Identifier));
_logger.LogDebug($"Published {nameof(TicketScanAdded)} event for transaction {notification.Identifier}");
return(Task.CompletedTask);
}
public Ticket Create(Ticket card)
{
if (IsValid(card))
{
irepo.Add(card);
return(card);
}
return(null);
}
public TicketModel Add(TicketModel model)
{
using (var scope = _contextScopeFactory.Create())
{
var entity = _mapper.Map <Ticket> (model);
_repository.Add(entity);
_repository.Save();
return(model);
}
}
/// <summary>
/// Create a ticket
/// </summary>
/// <param name="conversation">The conversation<see cref="Conversation"/></param>
/// <returns>The <see cref="Ticket"/></returns>
public async Task <Ticket> Create(Conversation conversation)
{
var ticket = new Ticket();
ticket.AddConversation(conversation);
var response = await _ticketRepository.Add(ticket);
return(response);
}
public async Task Execute(IUserContext userContext, CreateTicket command)
{
EnforceUserContext(userContext);
var ticketId = Guid.NewGuid();
await _ticketRepository.Add(new Ticket(ticketId, command.Title, command.Description));
await _handler.Handle(new TicketCreated(ticketId));
}
public IActionResult Create([Bind("Id,DateOpened,DateClosed,Description,ResolutionType")] Ticket ticket)
{
if (ModelState.IsValid)
{
_repo.Add(ticket);
_unitOfWork.Complete();
return(RedirectToAction(nameof(Index)));
}
return(View(ticket));
}
public void Handle(CreateTicketCommand message)
{
User requestor = _userRepository.GetByLoginName(message.RequestorLoginName);
User assignedTo = _userRepository.GetByLoginName(message.AssignedToLoginName);
Category category = _categoryRepository.GetByName(message.Category);
var ticket = new Ticket(message.Title, message.Description, (TicketStatus)message.Status, (TicketPriority)message.Priority, (TicketType)message.Type,
message.DueDate, message.ResolutionComments, requestor, assignedTo, category);
_ticketRepository.Add(ticket);
}
public Task <AddTicketCommandResponse> Handle(AddTicketCommandRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <AddTicketCommandResponse> next)
{
var ticket = new Ticket(request.Description, request.Title, CodeGenerator.CreateCode());
_ticketRepository.Add(ticket);
var ticketResponse = new TicketResponse
{
TrackingCode = ticket.TrackingCode
};
return(Task.FromResult(new AddTicketCommandResponse(true, ResultCode.Success, ticketResponse)));
}
public void Create(string title, string message, string userId)
{
var newTicket = new Ticket()
{
Title = title,
Message = message,
ClientId = userId,
DateCreated = DateTime.Now,
};
ticketRepository.Add(newTicket);
}
public void AddTestTicket()
{
if (_ticketRepo.GetAll().Count() > 0)
{
return;
}
var john = _userManager.FindByNameAsync("*****@*****.**").Result;
var jane = _userManager.FindByNameAsync("*****@*****.**").Result;
var johnTicket1 = CreateTestTicket(1, 3, "A4", "3:30", 1, 1, john);
_ticketRepo.Add(johnTicket1);
}
public IActionResult Add(TicketViewModel model)
{
if (ModelState.IsValid)
{
_repository.Add(model.CurrentTicket);
_repository.SaveChanges();
return(RedirectToAction("Tickets"));
}
else
{
model.Statuses = _repository.GetStatuses();
return(View(model));
}
}
public bool SaveTicket(Ticket ticketType)
{
if (ticketType.TicketId > 0)
{
ticketRepository.Update(ticketType);
}
else
{
ticketRepository.Add(ticketType);
}
ticketRepository.SaveChanges();
return(true);
}
Execute(IUserContext userContext, CreateTicket command)
{
if (!userContext.HasPermission(Permission.Edit))
{
return(false, $"Does not have role {Permission.Edit}");
}
var ticketId = Guid.NewGuid();
await _ticketRepository.Add(new Ticket(ticketId, command.Title, command.Description));
await _handler.Handle(new TicketCreated(ticketId));
return(true, string.Empty);
}
public MethodResult <Ticket> AddTicket(string description, int assetId)
{
var newTicket = new Ticket
{
Description = description,
DateOpen = DateTime.Now,
TicketStatus = TicketStatus.Open,
DateClosed = null,
AssetId = assetId
};
_ticketRepository.Add(newTicket);
return(new MethodResult <Ticket>(newTicket));
}
/// <summary>
/// Добавляет билет
/// </summary>
/// <param name="ticket">Модель билета</param>
/// <returns>Код ответа Create и добавленную модель</returns>
public async Task <string> Add(Ticket ticket)
{
var validationResultTicket = await _validatorTickets.ValidateAsync(ticket);
var validationResultUser = await _validatorUsers.ValidateAsync(ticket.User);
if (!validationResultTicket.IsValid | !validationResultUser.IsValid)
{
var errors = validationResultTicket.Errors.ToList();
errors.AddRange(validationResultUser.Errors.ToArray());
throw new ValidationException("Validation failed",
errors);
}
var res = await _context.Add(_mapper.Map <Data.DbModels.Ticket>(ticket));
try
{
await _policy.ExecuteAsync(async() =>
{
await _bus.PublishAsync(new TicketCreationMessage
{
TicketId = res,
Price = ticket.Price,
Name = ticket.Name,
City = ticket.LocationEvent.City,
Category = ticket.TypeEvent,
Date = DateTime.Now
});
await _bus.PublishAsync(new TicketActionLogMessage
{
TicketId = res,
UserId = ticket.User.UserInfoId,
ActionType = TicketAction.Add,
EventDate = DateTime.Now
});
});
}
catch (TimeoutException exception)
{
throw new EasyNetQSendException("Ticket added in db, but error sending message to RabbitMQ",
exception,
res);
}
return(res);
}
public IActionResult OnPost(Ticket SingleTicket)
{
if (ModelState.IsValid)
{
if (SingleTicket.ID > 0)
{
SingleTicket = ticketRepository.Update(SingleTicket);
}
else
{
SingleTicket = ticketRepository.Add(SingleTicket);
}
return(RedirectToPage("Index"));
}
return(Page());
}
public void canAdd()
{
List <Ticket> testTickets;
Ticket ticketNuevo = new Ticket()
{
TipoSolicitudId = 109,
Observacion = "Test2",
FechaCreacion = DateTime.Now,
UsuarioCreacionId = 1
};
TicketRepository.Add(ticketNuevo);
TicketRepository.Save();
testTickets = (List <Ticket>) this.TicketRepository.GetAll();
testTickets.Add(ticketNuevo);
Assert.AreEqual(2, testTickets.Count);
}
public async Task <bool> Handle(CreateTicket request, CancellationToken cancellationToken)
{
Ticket tickets = new Ticket(
Title.FromString(request.Title),
request.Description,
request.UserSenderId,
request.UserResiveId
);
_ticketRepository.Add(tickets);
int result = _unitOfWork.Commit();
foreach (var @event in tickets.GetEvents())
{
await _eventBus.Publish(@event);
}
return(true);
}
public async Task <IActionResult> CreateTicket([FromBody] TicketResource ticketResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var ticket = mapper.Map <TicketResource, Ticket>(ticketResource);
ticket.CreationDate = DateTime.Now;
repository.Add(ticket);
await unitOfWork.CompleteAsync();
ticket = await repository.Get(ticket.Id);
var result = mapper.Map <Ticket, TicketResource>(ticket);
return(Ok(result));
}
private Booking AddNewBooking(Booking booking, ITicketRepository ticketRepository)
{
try
{
var ticketResult = ticketRepository.Add(booking);
return ticketResult;
}
catch (NullReferenceException ex)
{
System.Console.WriteLine("Processor Usage" + ex.Message);
}
return null;
}
