public async Task Open_WhenProjectIdIsNotSpecified_VerifySingleAsyncForGetProjectByIdIsNotCalled()
{
var newTicket = new NewTicket
{
ProjectId = null
};
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockMapper = new Mock <IMapper>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(new Client());
mockMapper.Setup(m => m.Map <Ticket>(newTicket)).Returns(new Ticket());
var service = CreateService(
mockContext: mockContext,
mockMapper: mockMapper,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockContext.Verify(v => v.SingleAsync(It.IsAny <GetProjectById>()), Times.Never, "Should not call the context's SingleAsync method exactly once for GetProjectById.");
}
public void MapsOpenTicketDtoToTicket()
{
var newTicket = new NewTicket
{
Name = _fixture.Create <string>(),
Description = _fixture.Create <string>(),
Severity = _fixture.Create <Severity>(),
Priority = _fixture.Create <Priority>(),
DueDate = _fixture.Create <DateTimeOffset?>(),
ClientId = _fixture.Create <int>(),
ProjectId = _fixture.Create <int?>()
};
var ticket = _mapper.Map <Ticket>(newTicket);
Assert.Multiple(() =>
{
Assert.IsNotNull(ticket);
Assert.IsInstanceOf <Ticket>(ticket);
Assert.AreEqual(newTicket.Name, ticket.Name);
Assert.AreEqual(newTicket.Description, ticket.Description);
Assert.AreEqual(newTicket.Severity, ticket.Severity);
Assert.AreEqual(newTicket.Priority, ticket.Priority);
Assert.AreEqual(newTicket.DueDate, ticket.DueDate);
Assert.AreEqual(newTicket.ClientId, ticket.ClientId);
Assert.AreEqual(newTicket.ProjectId, ticket.ProjectId);
});
}
private void btnEditFlight_Click(object sender, RoutedEventArgs e)
{
if (currentTicket != null)
{
try
{
if (currentTicket.Ticket.Schedule.Date + currentTicket.Ticket.Schedule.Time < DateTime.Now)
{
MessageBox.Show("This ticket cannot be changed because the flight for this ticket took off!", "Message", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
EditTicketWindow wEditTicket = new EditTicketWindow();
wEditTicket.NewTicket = currentTicket;
wEditTicket.ManageWindow = this;
wEditTicket.ShowDialog();
currentTicket = null;
}
catch (Exception)
{
}
}
else
{
MessageBox.Show("Please choose a ticket!", "Message", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public void NullObjectReturnsNull()
{
NewTicket newTicket = null;
var item = _mapper.Map <Ticket>(newTicket);
Assert.IsNull(item);
}
public async Task Open_WhenTicketIsAdded_VerifyFactoryOpenedIsReturned()
{
var newTicket = new NewTicket();
var ticket = new Ticket();
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockMapper = new Mock <IMapper>();
var mockFactory = new Mock <IOpenTicketResultFactory>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(new Client());
mockMapper.Setup(m => m.Map <Ticket>(newTicket)).Returns(ticket);
var service = CreateService(
mockContext: mockContext,
mockMapper: mockMapper,
mockFactory: mockFactory,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockFactory.Verify(v => v.Opened(ticket), Times.Once, "Should call the factory's Opened method.");
}
public async Task Open_WhenTicketIsAdded_VerifyTickeOpenedNotificationIsQueued()
{
var newTicket = new NewTicket();
var ticket = new Ticket();
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockMapper = new Mock <IMapper>();
var mockNotificationService = new Mock <INotificationService>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(new Client());
mockMapper.Setup(m => m.Map <Ticket>(newTicket)).Returns(ticket);
var service = CreateService(
mockContext: mockContext,
mockMapper: mockMapper,
mockNotificationService: mockNotificationService,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockNotificationService.Verify(v => v.Queue(It.Is <TicketOpenedNotification>(a => a.TicketId == ticket.TicketId)), Times.Once, "Should queue a new TicketOpenedNotification.");
}
private void btnDeleteTicket_Click(object sender, RoutedEventArgs e)
{
if (currentTicket != null)
{
if (currentTicket.Ticket.Confirmed)
{
MessageBox.Show("You can only delete canceled ticket", "Message", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (MessageBox.Show("All information related to this ticket will be permanently deleted, do you want to delete this ticket?", "Message", MessageBoxButton.OKCancel, MessageBoxImage.Warning) == MessageBoxResult.OK)
{
var amenTickets = currentTicket.Ticket.AmenitiesTickets.ToList();
Db.Context.AmenitiesTickets.RemoveRange(amenTickets);
Db.Context.Tickets.Remove(currentTicket.Ticket);
Db.Context.SaveChanges();
LoadTickets();
currentTicket = null;
MessageBox.Show("Delete ticket successful!", "Message", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
else
{
MessageBox.Show("Please choose a ticket!", "Message", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public async Task Open_WhenClientAndProjectIdsDoNotMatch_VerifyFactoryProjectInaccessibleIsReturned()
{
var newTicket = new NewTicket
{
ClientId = _fixture.Create <int>(),
ProjectId = _fixture.Create <int>()
};
var client = new Client {
OrganizationId = _fixture.Create <int>()
};
var project = new Project {
OrganizationId = _fixture.Create <int>()
};
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockFactory = new Mock <IOpenTicketResultFactory>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(client);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetProjectById>())).ReturnsAsync(project);
var service = CreateService(
mockContext: mockContext,
mockFactory: mockFactory,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockFactory.Verify(v => v.ProjectInaccessible(client.ClientId, project.ProjectId), Times.Once, "Should return the factory's ProjectInaccessible method.");
}
public async Task Open_WhenProjectRecordIsNull_VerifyFactoryProjectNotFoundIsReturned()
{
var newTicket = new NewTicket
{
ProjectId = _fixture.Create <int>()
};
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockFactory = new Mock <IOpenTicketResultFactory>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(new Client());
mockContext.Setup(m => m.SingleAsync(It.Is <GetProjectById>(p => p._projectId == newTicket.ProjectId.Value))).ReturnsAsync((Project)null);
var service = CreateService(
mockContext: mockContext,
mockFactory: mockFactory,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockFactory.Verify(v => v.ProjectNotFound(newTicket.ProjectId.Value), Times.Once, "Should return the factory's ProjectNotFound method.");
}
public string Get(string id)
{
NewTicket x = new NewTicket();
x.response = new Global.Response();
try {
if (!string.IsNullOrEmpty(id))
{
using (SQLiteConnection connection = new SQLiteConnection(string.Format("Data Source={0}", Server.MapPath(dataSource)))) {
connection.Open();
string sql = string.Format("SELECT {0} FROM recipes WHERE id = '{1}'", mainSql, id);
using (SQLiteCommand command = new SQLiteCommand(sql, connection)) {
Clients.Client client = new Clients.Client();
using (SQLiteDataReader reader = command.ExecuteReader()) {
while (reader.Read())
{
x = GetData(reader);
}
}
}
}
}
x.response.isSuccess = true;
x.response.msg = "ok";
return(JsonConvert.SerializeObject(x, Formatting.None));
} catch (Exception e) {
x.response.isSuccess = true;
x.response.msg = e.Message;
L.SendErrorLog(e, id, null, "Tickets", "Get");
return(JsonConvert.SerializeObject(x, Formatting.None));
}
}
void ReleaseDesignerOutlets()
{
if (NewTicket != null)
{
NewTicket.Dispose();
NewTicket = null;
}
if (TicketsTable != null)
{
TicketsTable.Dispose();
TicketsTable = null;
}
}
public string Save(NewTicket x, bool sendMail, bool attachFile, string lang)
{
try {
//string path = Server.MapPath(string.Format("~/App_Data/{0}", dataBase));
//db.CreateGlobalDataBase(path, db.tickets);
if (string.IsNullOrWhiteSpace(x.id))
{
x.id = Convert.ToString(Guid.NewGuid());
}
Global G = new Global();
x.title = G.RemoveSingleQuotes(x.title);
x.desc = G.RemoveSingleQuotes(x.desc);
x.note = G.RemoveSingleQuotes(x.note);
string sql = string.Format(@"BEGIN;
INSERT OR REPLACE INTO tickets ({0})
VALUES ('{1}', '{2}', '{3}', '{4}', '{5}', '{6}', {7}, {8}, '{9}');
COMMIT;", mainSql, x.id, x.user.userId, x.title, x.desc, x.reportDate, x.filePath, x.status, x.priority, x.note);
using (SQLiteConnection connection = new SQLiteConnection(string.Format("Data Source={0}", Server.MapPath(dataSource)))) {
connection.Open();
using (SQLiteCommand command = new SQLiteCommand(sql, connection)) {
command.ExecuteNonQuery();
}
}
Users U = new Users();
x.user = U.GetUserInfo(x.user.userId);
if (sendMail)
{
Mail M = new Mail();
string myEmail = ConfigurationManager.AppSettings["myEmail"];
Global.Response mailResp = M.SendTicketMessage(myEmail, messageSubject: string.Format("TICKET - {0}", x.user.email), messageBody: x.desc, lang: lang, filePath: attachFile ? x.filePath : null, send_cc: true);
x.response = mailResp;
}
else
{
x.response.isSuccess = true;
x.response.msg = "successfully sent";
}
return(JsonConvert.SerializeObject(x, Formatting.None));
} catch (Exception e) {
x.response.isSuccess = false;
x.response.msg = e.Message;
L.SendErrorLog(e, x.id, x.user.userId, "Tickets", "Save");
return(JsonConvert.SerializeObject(x, Formatting.None));
}
}
public virtual async Task <OpenTicketResult> Open(NewTicket newTicket)
{
if (newTicket == null)
{
throw new ArgumentNullException(nameof(newTicket));
}
var validationResult = await _validator.ValidateAsync(newTicket);
if (!validationResult.IsValid)
{
return(_factory.ValidationFailure(validationResult.Errors));
}
var client = await _repository.SingleAsync(new GetClientById(newTicket.ClientId).AsNoTracking());
if (client == null)
{
return(_factory.ClientNotFound(newTicket.ClientId));
}
if (newTicket.ProjectId.HasValue)
{
var project = await _repository.SingleAsync(new GetProjectById(newTicket.ProjectId.Value).AsNoTracking());
if (project == null)
{
return(_factory.ProjectNotFound(newTicket.ProjectId.Value));
}
if (client.OrganizationId != project.OrganizationId)
{
return(_factory.ProjectInaccessible(client.ClientId, project.ProjectId));
}
}
var ticket = _mapper.Map <Ticket>(newTicket);
await _repository.AddAsync(ticket);
await _repository.SaveAsync();
var workflow = _workflowService.Process(new TicketOpenedWorkflow(ticket.TicketId));
var notification = _notificationService.Queue(new TicketOpenedNotification(ticket.TicketId));
await Task.WhenAll(workflow, notification);
return(_factory.Opened(ticket));
}
public IActionResult AddTicket(NewTicket ticket)
{
//проверить, сохранить, редиректнуть на "Спасибо"
ticket.CashierName = User.Identity.Name;
var result = new TicketService(db).AddNewTicket(ticket);
if (result.IndexOf("Ok") == 0)
{
string[] resultItems = result.Split(",");
new TicketHandler(db).WaitPaymentAsync(Convert.ToInt32(resultItems[1]));
return(RedirectToAction("Success"));
}
else
{
return(RedirectToAction("Error"));
}
}
public string Init()
{
NewTicket x = new NewTicket();
x.id = null;
x.title = null;
x.desc = null;
x.reportDate = DateTime.UtcNow.ToString();
x.user = new Users.NewUser();
x.fileName = null;
x.filePath = null;
x.status = (int)Status.pending;
x.priority = (int)Priority.height;
x.note = null;
x.response = new Global.Response();
return(JsonConvert.SerializeObject(x, Formatting.None));
}
public async Task Open_WhenNewTicketIsNotValid_VerifyFactoryValidationFailureIsReturned()
{
var newTicket = new NewTicket();
var mockFactory = new Mock <IOpenTicketResultFactory>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(false);
var service = CreateService(
mockFactory: mockFactory,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockFactory.Verify(v => v.ValidationFailure(mockValidationResult.Object.Errors), Times.Once, "Should return the factory's ValidationFailure method.");
}
public string Load(int?type, int?status)
{
try {
List <NewTicket> xx = new List <NewTicket>();
//string path = Server.MapPath(string.Format("~/App_Data/{0}", dataBase));
//db.CreateGlobalDataBase(path, db.tickets);
string sqlCondition = null;
string andCondition = type != null && status != null ? "AND" : null;
if (type == 0)
{
sqlCondition = "userId <> ''";
}
else if (type == 1)
{
sqlCondition = "userId = ''";
}
if (status != null)
{
sqlCondition = string.Format("{0} {1} status = {2}", sqlCondition, andCondition, status);
}
if (!string.IsNullOrWhiteSpace(sqlCondition))
{
sqlCondition = string.Format("WHERE {0}", sqlCondition);
}
string sql = string.Format(@"SELECT {0} FROM tickets {1} ORDER BY status, priority DESC", mainSql, sqlCondition);
using (SQLiteConnection connection = new SQLiteConnection(string.Format("Data Source={0}", Server.MapPath(dataSource)))) {
connection.Open();
using (SQLiteCommand command = new SQLiteCommand(sql, connection)) {
using (SQLiteDataReader reader = command.ExecuteReader()) {
while (reader.Read())
{
NewTicket x = GetData(reader);
xx.Add(x);
}
}
}
connection.Close();
}
return(JsonConvert.SerializeObject(xx, Formatting.None));
} catch (Exception e) {
L.SendErrorLog(e, null, null, "Tickets", "Load");
return(JsonConvert.SerializeObject(e.Message, Formatting.None));
}
}
private NewTicket GetData(SQLiteDataReader reader)
{
NewTicket x = new NewTicket();
x.id = reader.GetValue(0) == DBNull.Value ? null : reader.GetString(0);
string userId = reader.GetValue(1) == DBNull.Value ? null : reader.GetString(1);
Users U = new Users();
x.user = U.GetUserInfo(userId);
x.title = reader.GetValue(2) == DBNull.Value ? null : reader.GetString(2);
x.desc = reader.GetValue(3) == DBNull.Value ? null : reader.GetString(3);
x.reportDate = reader.GetValue(4) == DBNull.Value ? null : reader.GetString(4);
x.filePath = reader.GetValue(5) == DBNull.Value ? null : reader.GetString(5);
x.status = reader.GetValue(6) == DBNull.Value ? 0 : reader.GetInt32(6);
x.priority = reader.GetValue(7) == DBNull.Value ? 0 : reader.GetInt32(7);
x.note = reader.GetValue(8) == DBNull.Value ? null : reader.GetString(8);
x.response = new Global.Response();
return(x);
}
public async Task Open_ForCleint_VerifySingleAsyncForGetClientByIdIsCalled()
{
var newTicket = new NewTicket
{
ClientId = _fixture.Create <int>()
};
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
var service = CreateService(
mockContext: mockContext,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockContext.Verify(v => v.SingleAsync(It.Is <GetClientById>(c => c._clientId == newTicket.ClientId)), Times.Once, "Should call the context's SingleAsync method exactly once for GetClientById.");
}
private void DgTickets_SelectedCellsChanged(object sender, SelectedCellsChangedEventArgs e)
{
try
{
currentTicket = dgTickets.CurrentItem as NewTicket;
if (currentTicket.Ticket.Confirmed)
{
btnCancelTicket.Content = "Cancel Flight";
btnCancelTicket.Foreground = new SolidColorBrush(Colors.Red);
}
else
{
btnCancelTicket.Content = "Confirm Flight";
btnCancelTicket.Foreground = new SolidColorBrush(Colors.Black);
}
}
catch (Exception)
{
}
}
protected void LoadData()
{
con.Open();
DataSet ds = new DataSet();
DataSet ds2 = new DataSet();
DataSet ds3 = new DataSet();
DataTable DeptNOTable = new DataTable();
SqlDataAdapter adapter = new SqlDataAdapter("SELECT DepartementNo from Employee WHERE Email = '" + Session["Email"].ToString() + "'", con);
adapter.Fill(ds);
string getDeptNo = ds.Tables[0].Rows[0]["DepartementNo"].ToString();
Session["DepNo"] = getDeptNo;
int deptToNo = Int32.Parse(getDeptNo);
SqlDataAdapter adapter2 = new SqlDataAdapter("SELECT TicketNo, Title, Date,Status, Content, DepartementNo from Ticket WHERE EmployeeEmail is null and DepartementNo =" + deptToNo + "", con);
adapter2.Fill(ds2);
if (ds2.Tables[0].Rows.Count > 0)
{
NewTicket.DataSource = ds2;
NewTicket.DataBind();
}
else
{
meassge_lbl.Visible = true;
meassge_lbl.Text = "There is no new requests to Assign";
}
con.Close();
}
public async Task Open_VerifySaveAsyncIsCalled()
{
var newTicket = new NewTicket();
var ticket = new Ticket();
var mockContext = new Mock <IContextRepository <ITicketContext> >();
var mockMapper = new Mock <IMapper>();
var mockValidator = new Mock <IValidator <NewTicket> >();
var mockValidationResult = new Mock <ValidationResult>();
mockValidator.Setup(m => m.ValidateAsync(newTicket, It.IsAny <CancellationToken>())).ReturnsAsync(mockValidationResult.Object);
mockValidationResult.Setup(m => m.IsValid).Returns(true);
mockContext.Setup(m => m.SingleAsync(It.IsAny <GetClientById>())).ReturnsAsync(new Client());
mockMapper.Setup(m => m.Map <Ticket>(newTicket)).Returns(ticket);
var service = CreateService(
mockContext: mockContext,
mockMapper: mockMapper,
mockValidator: mockValidator);
var result = await service.Open(newTicket);
mockContext.Verify(v => v.SaveAsync(), Times.Once, "Should call the context's SaveAsync.");
}
public string AddNewTicket(NewTicket ticketInfo)
{
try
{
DateTime ticketDateTime = DateTime.Now.Date;
string cashierId = db.Users.Where(u => u.Email == ticketInfo.CashierName).Select(u => u.Id).First();
ticketInfo.Document.Value = ticketInfo.Document.Value.Replace(" ", "");
var documentType = EnumExtensions.GetEnumObjectByValue <DocumentType>(ticketInfo.Document.Type);
int passengerId = -1;
Passenger passenger = (from p in db.Passengers
join dc in db.Document on p.Id equals dc.PassengerId
where dc.DocumentType == documentType &
dc.Value == ticketInfo.Document.Value
select new Passenger
{
Id = p.Id,
Age = p.Age,
Birthday = p.Birthday,
Documents = p.Documents,
BonusCardId = p.BonusCardId,
Citizenship = p.Citizenship,
Email = p.Email,
Gender = p.Gender,
Name = p.Name,
Notes = p.Notes,
PasswordHash = p.PasswordHash,
Patronumic = p.Patronumic,
Phone = p.Phone,
Surname = p.Surname
}).FirstOrDefault();
if (passenger != null)
{
passengerId = passenger.Id;
passenger.Age = ticketInfo.Passenger.Age;
passenger.Birthday = ticketInfo.Passenger.Birthday;
passenger.Citizenship = ticketInfo.Passenger.Citizenship;
passenger.Email = ticketInfo.Passenger.Email;
passenger.Phone = ticketInfo.Passenger.Phone;
passenger.Gender = ticketInfo.Passenger.Gender;
passenger.Name = ticketInfo.Passenger.Name;
passenger.Patronumic = ticketInfo.Passenger.Patronumic;
passenger.Surname = ticketInfo.Passenger.Surname;
if (!String.IsNullOrEmpty(ticketInfo.Passenger.Phone))
{
passenger.Phone = ticketInfo.Passenger.Phone;
}
if (!String.IsNullOrEmpty(ticketInfo.Passenger.Notes))
{
passenger.Notes = ticketInfo.Passenger.Notes;
}
db.Passengers.Update(passenger);
Document document = db.Document.Where(dc => dc.PassengerId == passenger.Id && dc.DocumentType == documentType).FirstOrDefault();
if (document != null)
{
document.Value = ticketInfo.Document.Value;
db.Document.Update(document);
}
else
{
db.Document.Add(new Document
{
PassengerId = passengerId,
DocumentType = documentType,
Value = ticketInfo.Document.Value
});
}
db.SaveChanges();
}
else
{
db.Passengers.Add(ticketInfo.Passenger);
db.SaveChanges();
passengerId = ticketInfo.Passenger.Id;
db.Document.Add(new Document
{
PassengerId = passengerId,
DocumentType = documentType,
Value = ticketInfo.Document.Value
});
db.SaveChanges();
}
Ticket newTicket = new Ticket
{
CashierId = cashierId,
DateTime = DateTime.Now,
FlightId = ticketInfo.FlightId,
PassengerId = passengerId,
RateId = ticketInfo.RateId
};
db.Tickets.Add(newTicket);
db.SaveChanges();
return("Ok," + newTicket.Id.ToString() + "," + ticketInfo.Passenger.Email);
}
catch (Exception ex)
{
return(ex.Message);
}
}
