public void Execute(TicketCreateDto request)
{
_validator.ValidateAndThrow(request);
var ticket = _mapper.Map<Ticket>(request);
_context.Tickets.Add(ticket);
_context.SaveChanges();
}
public ActionResult <TicketReadDto> CreateTicket(TicketCreateDto ticketCreateDto)
{
var ticketModel = _mapper.Map <TicketModel>(ticketCreateDto);
_ticketRepository.CreateTicket(ticketModel);
_ticketRepository.SaveChanges();
var ticketReadDto = _mapper.Map <TicketReadDto>(ticketModel);
return(CreatedAtRoute(nameof(GetTicketById), new { Id = ticketReadDto.id }, ticketReadDto));
}
public TicketCreateViewModel()
{
TicketCreateDto = new TicketCreateDto();
Groups = new List <GroupDto>();
Clients = new List <ClientDto>();
Branches = new List <BranchDto>();
PointCommunicationTypes = new List <PointCommunicationTypeDto>();
PointContactPhones = new List <PointContactPhoneDto>();
TicketSubjectParents = new List <TicketSubjectDto>();
TicketSubjectFirstChildren = new List <TicketSubjectDto>();
TicketSubjectLastChildren = new List <TicketSubjectOptionDto>();
}
public Ticket BookTicket(TicketCreateDto dto, string UserId)
{
CheckPublishedShowtime(dto.ShowTimeId);
CheckSeatInRange(dto.Seat, dto.ShowTimeId);
CheckDupplicatedSeat(dto.Seat, dto.ShowTimeId);
Ticket entity = new Ticket
{
Seat = dto.Seat,
ShowTimeId = dto.ShowTimeId,
TicketTypeId = dto.TicketTypeId,
UserId = UserId
};
return(repository.Add(entity));
}
public void BookUserTickets(TicketBookDto dto, string UserId)
{
foreach (string ticket in dto.Tickets)
{
string[] ticketInfos = ticket.Split(',');
int ShowTimeId = Int32.Parse(ticketInfos[0]);
int TicketTypeId = Int32.Parse(ticketInfos[1]);
string Seat = ticketInfos[2];
TicketCreateDto createDto = new TicketCreateDto
{
Seat = Seat,
ShowTimeId = ShowTimeId,
TicketTypeId = TicketTypeId,
UserId = UserId
};
BookTicket(createDto, UserId);
}
}
public async Task <ActionResult <IEnumerable <TicketReadDto> > > CreateTicketAsync(TicketCreateDto ticket)
{
if (ticket.DaThanhToan > await _busTripService.GetPriceByBusTripAsync(ticket.MaChuyenXe))
{
return(BadRequest());
}
foreach (var seatId in ticket.MaChoNgoi)
{
if (await _ticketService.CheckAvailableAsync(ticket.MaChuyenXe, ticket.NgayDi, seatId) == true)
{
return(BadRequest());
}
}
List <Vexe> list = new List <Vexe>();
foreach (var seatId in ticket.MaChoNgoi)
{
Vexe item = new Vexe
{
MaChoNgoi = seatId,
MaChuyenXe = ticket.MaChuyenXe,
MaKh = ticket.MaKh,
GhiChu = ticket.GhiChu,
NgayDi = ticket.NgayDi,
DaThanhToan = ticket.DaThanhToan,
MaKhNavigation = await _userService.GetUserByIdAsync(ticket.MaKh),
MaChuyenXeNavigation = await _busTripService.GetBusTripByIdAsync(ticket.MaChuyenXe),
};
list.Add(item);
}
await _ticketService.CreateTicketAsync(list);
IEnumerable <TicketReadDto> ticketReturn = _mapper.Map <IEnumerable <TicketReadDto> >(list);
return(Ok(ticketReturn));
}
public async Task <IActionResult> CreateTicket(TicketCreateDto ticket)
{
var newTicket = await _service.CreateNewAsync(_mapper.Map <Ticket>(ticket));
return(Ok(_mapper.Map <TicketReadDto>(newTicket)));
}
public Ticket CreateTicket(TicketCreateDto dto)
{
return(BookTicket(dto, dto.UserId));
}
public async Task <IActionResult> CreateTicket([FromBody] TicketCreateDto ticketCreate)
{
var createdById = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
User createdBy = await _userRepo.GetUser(createdById);
if (createdBy == null)
{
ModelState.AddModelError("CreatedBy", "User does not exist");
}
User assignedTo = await _userRepo.GetUser(ticketCreate.AssignedToId);
if (assignedTo == null)
{
ModelState.AddModelError("AssignedTo", "User does not exist");
}
Client client = await _clientRepo.GetClient(ticketCreate.ClientId);
if (client == null)
{
ModelState.AddModelError("Client", "Client does not exist");
}
ConfigItem item = await _clientRepo.GetConfigItem(ticketCreate.ConfigItemId);
if (item == null)
{
ModelState.AddModelError("Config Item", "Configuration Item does not exist");
}
TicketPriority priority = await _repo.GetTicketPriority(ticketCreate.TicketPriorityId);
if (priority == null)
{
ModelState.AddModelError("Ticket Priority", "Priority does not exist");
}
TicketStatus status = await _repo.GetTicketStatus(ticketCreate.TicketStatusId);
if (status == null)
{
ModelState.AddModelError("Ticket Status", "Ticket Status does not exist");
}
TicketType type = await _repo.GetTicketType(ticketCreate.TicketTypeId);
if (type == null)
{
ModelState.AddModelError("Ticket Type", "Ticket Type does not exisit");
}
TicketQueue queue = await _repo.GetTicketQueue(ticketCreate.TicketQueueId);
if (queue == null)
{
ModelState.AddModelError("Queue", "Ticket Queue does not exisit");
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createdAt = DateTime.Now;
var updatedAt = DateTime.Now;
Ticket newTicket = new Ticket
{
Description = ticketCreate.Description,
Details = ticketCreate.Details,
CreatedAt = createdAt,
UpdatedAt = updatedAt,
AssignedTo = assignedTo,
CreatedBy = createdBy,
TicketPriority = priority,
TicketStatus = status,
TicketType = type,
TicketQueue = queue,
Client = client,
ConfigItem = item
};
_repo.Create(newTicket);
if (await _repo.Save())
{
var ticketToReturn = _mapper.Map <TicketDetailDto>(newTicket);
return(CreatedAtRoute("GetTicket", new { controller = "Tickets", id = newTicket.Id }, ticketToReturn));
}
return(BadRequest());
}
public IActionResult Post([FromBody] TicketCreateDto dto, [FromServices] ICreateTicketCommand command)
{
_executor.ExecuteCommand(command, dto);
return(Ok("uneto"));
}
