public async Task ShouldGetTicketById()
{
List <TicketsToBuyVm> tickets = new List <TicketsToBuyVm>();
tickets.Add(new TicketsToBuyVm {
Id = 1
});
await CreateTickets(tickets);
TicketService ticketService = new TicketService(_dbContext, _mainEventProvider);
TicketController ticketController = new TicketController(ticketService);
ActionResult <TicketVm> result1 = await ticketController.GetTicketAsync(1);
TicketVm returnedTicket1 = result1.Value;
Assert.AreEqual(1, returnedTicket1.Id);
Assert.AreEqual(15, returnedTicket1.Price);
ActionResult <TicketVm> result2 = await ticketController.GetTicketAsync(2);
TicketVm returnedTicket2 = result2.Value;
Assert.AreEqual(2, returnedTicket2.Id);
Assert.AreEqual(10, returnedTicket2.Price);
}
public async Task ShouldUpdateTicket()
{
List <TicketsToBuyVm> tickets = new List <TicketsToBuyVm>();
tickets.Add(new TicketsToBuyVm {
Id = 1
});
await CreateTickets(tickets);
int newPrice = 50;
TicketService ticketService = new TicketService(_dbContext, _mainEventProvider);
TicketController ticketController = new TicketController(ticketService);
SetUser(ticketController, _createdUser1.Entity.Id);
TicketVm ticketVm = new TicketVm {
Id = 1, Price = newPrice
};
await ticketController.UpdateTicketAsync(ticketVm);
// Check that only one has been changed
Ticket ticket1 = _dbContext.Tickets.Find(1);
Assert.AreEqual(newPrice, ticket1.Price);
Ticket ticket2 = _dbContext.Tickets.Find(2);
Assert.AreEqual(10, ticket2.Price);
}
public async Task ShouldDeleteTicket()
{
List <TicketsToBuyVm> tickets = new List <TicketsToBuyVm>();
tickets.Add(new TicketsToBuyVm {
Id = 1
});
await CreateTickets(tickets);
TicketService ticketService = new TicketService(_dbContext, _mainEventProvider);
TicketController ticketController = new TicketController(ticketService);
SetUser(ticketController, _createdUser1.Entity.Id);
TicketVm ticketVm = new TicketVm {
Id = 1
};
ActionResult <TicketVm> result = await ticketController.DeleteTicketAsync(ticketVm);
TicketVm deletedTicket = (TicketVm)((OkObjectResult)result.Result).Value;
Assert.AreEqual(1, deletedTicket.Id);
// Check that we have deleted only the first, but not the other
Ticket ticket1 = _dbContext.Tickets.Find(1);
Assert.IsNull(ticket1);
Ticket ticket2 = _dbContext.Tickets.Find(2);
Assert.IsNotNull(ticket2);
}
public void TicketController_Throws_BadRequestException_When_Payment_Is_Zero()
{
// Arrange
TicketRepository ticketRepository = new TicketRepository(null);
PaymentWorker paymentWorker = new PaymentWorker(ticketRepository);
TicketController controller = new TicketController(paymentWorker);
GSPRPaymentRequest paymentRequest = new
GSPRPaymentRequest()
{
BillNo = 123,
BillAmount = 0,
PaymentTypeId = "100",
TipAmount = 0,
TransactionID = 123,
LocationIdentifier = "ABC",
PaymentTypeName = "3rd_party",
GlancePayPOSPaymentID = 123
};
MockControllerRequest(controller);
// Act
controller.Validate(paymentRequest);
HttpResponseMessage result = controller.Post(paymentRequest) as HttpResponseMessage;
}
public async Task Test2()
{
// Arrange (ülesseadmine)
var builder = new DbContextOptionsBuilder <TicketContext>()
.UseInMemoryDatabase("TicketList");
var context = new TicketContext(builder.Options);
var controller = new TicketController(context);
var tTicket = new TicketItem()
{
Id = 123
};
await controller.PostTicketItem(tTicket);
tTicket.query = "test";
// Act (käivitad "system under test")
var badRequestResult = await controller.PutTicketItem(999, tTicket);
var correctResult = await controller.PutTicketItem(123, tTicket);
// Assert
Assert.IsType <BadRequestResult>(badRequestResult);
var newContext = new TicketContext(builder.Options);
var ticketFromDatabase = newContext.TicketItems.Single();
Assert.True(ticketFromDatabase.query == "test");
Assert.IsType <NoContentResult>(correctResult);
}
public async Task Test1()
{
// Arrange (ülesseadmine)
var builder = new DbContextOptionsBuilder <TicketContext>()
.UseInMemoryDatabase("TicketList");
var context = new TicketContext(builder.Options);
var controller = new TicketController(context);
var tTicket = new TicketItem()
{
};
// Act (käivitad "system under test")
var returnVal = await controller.PostTicketItem(tTicket);
// Assert (vaatad et tulemus oleks nii nagu peab)
var newContext = new TicketContext(builder.Options);
var ticketFromDatabase = newContext.TicketItems.Single();
Assert.True(newContext.TicketItems.Contains(tTicket)); // bugine tegelt... referencide teema
Assert.IsType <CreatedAtActionResult>(returnVal.Result);
var returnVal2 = returnVal.Result as CreatedAtActionResult;
Assert.True(returnVal2.Value.Equals(tTicket));
}
public async Task ShouldGetAllTiccketsUserEvent()
{
List <TicketsToBuyVm> tickets = new List <TicketsToBuyVm>();
tickets.Add(new TicketsToBuyVm {
Id = 1
});
await CreateTickets(tickets);
TicketService ticketService = new TicketService(_dbContext, _mainEventProvider);
TicketController ticketController = new TicketController(ticketService);
SetUser(ticketController, _createdUser1.Entity.Id);
ActionResult <List <TicketListVm> > result = await ticketController.GetAllTiccketsUserEventAsync(1);
List <TicketListVm> returnedTickets = (List <TicketListVm>)((OkObjectResult)result.Result).Value;
Assert.AreEqual(2, returnedTickets.Count);
Assert.AreEqual("Event 1", returnedTickets[0].MainEventName);
Assert.AreEqual(15, returnedTickets[0].Price);
Assert.AreEqual("Test ticket type", returnedTickets[0].TicketType);
Assert.AreEqual(_createdUser1.Entity.Id, returnedTickets[0].UserId);
Assert.AreEqual("Test row name", returnedTickets[0].RowName);
Assert.AreEqual("Event 1", returnedTickets[1].MainEventName);
Assert.AreEqual(10, returnedTickets[1].Price);
Assert.AreEqual("Test ticket type", returnedTickets[1].TicketType);
Assert.AreEqual(_createdUser1.Entity.Id, returnedTickets[1].UserId);
}
public async void Patch_No_Errors()
{
TicketControllerMockFacade mock = new TicketControllerMockFacade();
var mockResult = new Mock <UpdateResponse <ApiTicketResponseModel> >();
mockResult.SetupGet(x => x.Success).Returns(true);
mock.ServiceMock.Setup(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTicketRequestModel>()))
.Callback <int, ApiTicketRequestModel>(
(id, model) => model.PublicId.Should().Be("A")
)
.Returns(Task.FromResult <UpdateResponse <ApiTicketResponseModel> >(mockResult.Object));
mock.ServiceMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult <ApiTicketResponseModel>(new ApiTicketResponseModel()));
TicketController controller = new TicketController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiTicketModelMapper());
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var patch = new JsonPatchDocument <ApiTicketRequestModel>();
patch.Replace(x => x.PublicId, "A");
IActionResult response = await controller.Patch(default(int), patch);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
mock.ServiceMock.Verify(x => x.Update(It.IsAny <int>(), It.IsAny <ApiTicketRequestModel>()));
}
public void GetTopOpenedShoudRednerPartialView_GetTopOpened()
{
var controller = new TicketController(null, null);
controller.WithCallTo(x => x.GetTopOpened())
.ShouldRenderPartialView("_GetTopOpened");
}
public async Task <IActionResult> OnPost()
{
var userId = HttpContext.Session.GetInt32("UserId");
if (userId == null)
{
Response.Redirect("Login");
}
if (ModelState.IsValid)
{
var ticketController = new TicketController(_configRoot);
var workerId = int.Parse(Request.Form["WorkerId"]);
_Title = Request.Form["_Title"];
Description = Request.Form["Description"];
var loggerId = int.Parse(Request.Form["LoggerId"]);
var ticket = new Models.Ticket(workerId, _Title, Description, null, loggerId, null, null);
if (await ticketController.Insert(ticket))
{
Response.Redirect("/Tickets");
}
}
return(Page());
}
public async void BulkInsert_No_Errors()
{
TicketControllerMockFacade mock = new TicketControllerMockFacade();
var mockResponse = new CreateResponse <ApiTicketResponseModel>(new FluentValidation.Results.ValidationResult());
mockResponse.SetRecord(new ApiTicketResponseModel());
mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiTicketRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiTicketResponseModel> >(mockResponse));
TicketController controller = new TicketController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object);
controller.ControllerContext = new ControllerContext();
controller.ControllerContext.HttpContext = new DefaultHttpContext();
var records = new List <ApiTicketRequestModel>();
records.Add(new ApiTicketRequestModel());
IActionResult response = await controller.BulkInsert(records);
response.Should().BeOfType <OkObjectResult>();
(response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK);
var result = (response as OkObjectResult).Value as List <ApiTicketResponseModel>;
result.Should().NotBeEmpty();
mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiTicketRequestModel>()));
}
public void Create_Ticket_Will_Be_Success(Ticket ticketOk1, Ticket ticketOk2, Ticket ticketOk3)
{
using (var context = new InMemoryDbContextFactory().GetDbContext())
{
var repositoryTicket = new Repository <Ticket, int>(context);
var repositoryPriority = new Repository <Priority, int>(context);
var repositoryStatus = new Repository <Status, int>(context);
var repositoryTicketType = new Repository <TicketType, int>(context);
var serviceTicket = new TicketService(repositoryTicket);
var serviceParameters = new ParametersService(repositoryPriority, repositoryStatus, repositoryTicketType);
using (var controller = new TicketController(serviceTicket, serviceParameters))
{
int cantidad = 1;
foreach (var ticket in new List <Ticket> {
ticketOk1, ticketOk2, ticketOk3
})
{
var result = controller.Create(ticket);
var viewResult = Assert.IsType <RedirectToActionResult>(result.Result);
Assert.Equal(cantidad, serviceTicket.GetAll().Result.Count);
cantidad++;
}
}
}
}
public void Details_WithValidId_ReturnsViewResultWithTicket()
{
// arrange
int ticketId = 1;
var mgr = new Mock <ITicketManager>();
mgr
.Setup(x => x.GetTicket(ticketId))
.Returns(TestTicketsProvider.GetTestTickets().FirstOrDefault(ticket => ticket.TicketNumber == ticketId));
var controller = new TicketController(mgr.Object);
var ticketThatShouldBeReturned = TestTicketsProvider.GetTestTickets().First(t => t.TicketNumber == ticketId);
// act
var result = controller.Details(ticketId);
// assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <Ticket>(viewResult.Model);
Assert.Equal(ticketThatShouldBeReturned.TicketNumber, model.TicketNumber);
Assert.Equal(ticketThatShouldBeReturned.AccountId, model.AccountId);
Assert.Equal(ticketThatShouldBeReturned.Text, model.Text);
Assert.Equal(ticketThatShouldBeReturned.DateOpened, model.DateOpened);
Assert.Equal(ticketThatShouldBeReturned.State, model.State);
// Assert.Equal(ticketThatShouldBeReturned.Responses, model.Responses);
// bool responesEqual = ticketThatShouldBeReturned.Responses.SequenceEqual(model.Responses);
// Assert.True(responesEqual);
}
public void PutTicketStateToClosed_WithValidId_ReturnsNoContentAndUpdatesTicket()
{
// arrange
int ticketId = 1;
var mgr = new Mock <ITicketManager>();
mgr
.Setup(x => x.GetTicket(ticketId))
.Returns(new Ticket()
{
TicketNumber = ticketId,
State = TicketState.Open
});
var controller = new TicketsController(mgr.Object);
// act
var result = controller.PutTicketStateToClosed(ticketId);
// assert
// var notFoundResult = Assert.IsType<NotFoundResult>(result);
Assert.IsType <NoContentResult>(result);
var ctrl2 = new TicketController(mgr.Object);
Assert.Equal(TicketState.Closed, ((Ticket)((ViewResult)ctrl2.Details(ticketId)).Model).State);
}
public async Task Test3()
{
// Arrange (ülesseadmine)
var builder = new DbContextOptionsBuilder <TicketContext>()
.UseInMemoryDatabase("TicketList");
var context = new TicketContext(builder.Options);
var controller = new TicketController(context);
var deletedTicket = new TicketItem()
{
Id = 123
};
await controller.PostTicketItem(deletedTicket);
await controller.PostTicketItem(new TicketItem()
{
Id = 555
});
// Act (käivitad "system under test")
var deleteRequest = await controller.DeleteTicketItem(deletedTicket.Id);
var wrongKeyRequest = await controller.DeleteTicketItem(99);
// Assert
Assert.False(context.TicketItems.Any(x => x.Id == deletedTicket.Id));
Assert.IsType <NotFoundResult>(wrongKeyRequest);
Assert.IsType <NoContentResult>(deleteRequest);
}
public void TicketDeleteTest()
{
var ac = new TicketController();
var r = ac.Delete(1) as ViewResult;
Assert.IsNotNull(r);
}
public void PutTicket()
{
// Arrange
TicketController controller = new TicketController();
Ticket TicketObj = new Ticket
{
User = new User {
ID = 1
},
Concern = "Put request sucessfull",
Department = new Department {
ID = 1, Name = "EBS"
},
Description = "Not able to connect with bit bucket",
Priority = Espl.Linkup.Domain.Enums.Enum.Priority.High,
CreatedOn = new DateTime(2016, 10, 10),
Status = "Closed",
Isclosed = true,
IsReopen = true,
ID = 1
};
var actResult = controller.Put(1, TicketObj);
// Act
var result = actResult as OkNegotiatedContentResult <Ticket>;
// Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Content.Concern.Equals("Put request sucessfull"));
}
[Fact] // Good Test
public void GetAllTickets_ReturnsAllTickets_ListOfTicketsOkObjectResult()
{
var tList = new List <Ticket>
{
new Ticket()
{
TicketId = 123
}, new Ticket()
{
TicketId = 234
}
};
//Arrange
repoStub.Setup(repo => repo.GetAllTickets()).Returns(tList);
//Act
var controller = new TicketController(repoStub.Object);
var result = controller.GetAllTickets();
//Assert
repoStub.VerifyAll();
var returnList = Assert.IsType <OkObjectResult>(result);
Assert.IsType <OkObjectResult>(result);
Assert.Equal(tList, returnList.Value);
}
// Updates our current value with the values in the fields.
public async Task <IActionResult> OnPost()
{
if (ModelState.IsValid)
{
int.TryParse(Request.Form["TicketId"], out var ticketId);
int.TryParse(Request.Form["LoggerId"], out var loggerId);
var workerId = int.Parse(Request.Form["WorkerId"]);
int.TryParse(Request.Form["StatusIndCd"], out var statusValue);
var statusIndCd = (StatusIndCd)statusValue;
_Title = Request.Form["_Title"].ToString();
Description = Request.Form["Description"].ToString();
Resolution = Request.Form["Resolution"].ToString();
var ticketController = new TicketController(_configRoot);
var updateTicket =
new Models.Ticket(workerId,
_Title,
Description,
Resolution,
loggerId,
statusIndCd,
ticketId);
if (await ticketController.Update(updateTicket))
{
return(new RedirectToPageResult("Tickets"));
}
}
return(Page());
}
void Start()
{
dev = Developer.GetInstalce();
ticketController = FindObjectOfType <TicketController>();
ticketController.callreadSprint();
message = ticketController.sprintData.error;
dropdownSprint = dropdownSprintObject.GetComponent <Dropdown>();
dropdownSprint.ClearOptions();
dropdownSprint.AddOptions(ticketController.sprintList);
boardController = FindObjectOfType <BoardController>();
boardController.callRead();
message = message + boardController.boardData.error;
dropdownProject = dropdownProjectObject.GetComponent <Dropdown>();
dropdownProject.ClearOptions();
List <string> data = new List <string>();
foreach (Board item in boardController.rootboard.boards)
{
data.Add(item.Id.ToString());
}
dropdownProject.AddOptions(data);
if (!string.IsNullOrEmpty(ticketController.sprintData.error) && !string.IsNullOrEmpty(boardController.boardData.error))
{
popUp = FindObjectOfType <PopUpScript>();
popUp.Show(message);
}
}
public ControlTicketList(ActionTabViewModel vmd)
{
_vmd = vmd;
_ticketController = new TicketController();
this.DataContext = _ticketController;
InitializeComponent();
}
public void Reset()
{
_ticketController = null;
_uow = null;
_mapper = null;
_ticketService = null;
}
static void Main(string[] args)
{
var controller = new TicketController();
var controllerDepartment = new DepartmentController();
var controllerEmployee = new EmployeeController();
var ticket2 = new TicketPostModel
{
Title = "Title3",
Description = "Ticket Description2",
Date = System.DateTime.Now,
//DepartmentId = 6,
};
var ticketDepartment = new DepartmentPostModel
{
name = "Department1"
};
var ticketEmployee = new EmployeePostModel
{
name = "Yasha",
//DepartmentId = 6,
};
//var CreateTicketEmployee = controllerEmployee.CreateTicketEmployee(ticketEmployee);
//var GetByIdEmployee = controllerEmployee.GetById(1);
var GetAllTicketEmployee = controllerEmployee.GetAll();
//var CreateTicketDepartment = controllerDepartment.CreateTicketDepartment(ticketDepartment);
var GetAllTicketDepartment = controllerDepartment.GetAll();
//var CreateTicket = controller.CreateTicket(ticket2);
//var GetById = controller.GetById(3);
var GetAll = controller.GetAll();
var DelById = controller.DelById(3);
}
public void SearchTestWithCompleteAndIncompleteTerms()
{
//Arrange
var controller = new TicketController(new StationService(new StationRepository(new CacheStation(new DbContext()))));
var expected = new StationResponse
{
Stations = new List <string>
{
"LIVERPOOL",
"LIVERPOOL LIME STREET"
},
NextCharacters = new List <string>
{
" "
}
};
//Act
var result = controller.GetStation("LIVERPOOL") as OkNegotiatedContentResult <StationResponse>;
//Assert
Assert.IsNotNull(result.Content);
CollectionAssert.AreEqual(expected.Stations, result.Content.Stations);
CollectionAssert.AreEqual(expected.NextCharacters, result.Content.NextCharacters);
}
public void StartUp()
{
var optionsBuilder = new DbContextOptionsBuilder <AirportContext>();
optionsBuilder.UseSqlServer(@"Server = (localdb)\mssqllocaldb; Database = AirportDB; Trusted_Connection = True; ConnectRetryCount = 0");
_context = new AirportContext(optionsBuilder.Options);
_mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <TicketDTO, Ticket>()
.ForMember(x => x.Id, opt => opt.Ignore());
cfg.CreateMap <Ticket, TicketDTO>();
cfg.CreateMap <CrewDTO, Crew>()
.ForMember(i => i.Id, opt => opt.Ignore())
.ForMember(i => i.Stewardesses, opt => opt.Ignore())
.ForMember(i => i.Pilot, opt => opt.Ignore());
cfg.CreateMap <Crew, CrewDTO>()
.ForMember(i => i.StewardessesId, opt => opt.MapFrom(m => m.Stewardesses.Select(s => s.Id)))
.ForMember(i => i.PilotId, opt => opt.MapFrom(m => m.Pilot.Id));
cfg.CreateMap <Ticket, TicketDTO>();
}).CreateMapper();
_uow = new UnitOfWork(_context);
_ticketService = new TicketService(_uow, _mapper);
_crewService = new CrewService(_uow, _mapper);
_crewController = new CrewController(_crewService);
_ticketController = new TicketController(_ticketService);
}
public void TicketTest()
{
var tc = new TicketController();
var r = tc.Index("", "", "", 1) as ViewResult;
Assert.IsInstanceOfType(r, typeof(ViewResult));
}
public static void ProcessTicketResponce(WorldClient Client, string Ticket)
{
var a_ticket = TicketController.GetTicket(Ticket);
lock (ticketProcess)
{
if (a_ticket == null)
{
Client.Send(new AccountTicketErrorMessage());
return;
}
else
{
Client.Account = a_ticket.Account;
if (CharacterTable.myCharacterById.Values.Where(x => x.Account != null && x.Account.ID == Client.Account.ID).Count() > 0)
{
CharacterTable.myCharacterById.Values.Where(x => x.Account != null && x.GetClient() != null && x.Account.ID == Client.Account.ID).ToList().ForEach(x => x.Client.Disconnect());
Client.Send(new AccountTicketErrorMessage());
return;
}
AccountTable.UpdateLogged(Client.Account.ID, true);
Client.Account.Characters = CharacterTable.FindAll(Client.Account.ID);
Client.Account.Characters.Values.ToList().ForEach(x => x.Account = Client.Account);
Client.SetState(WorldState.STATE_AUTHENTIFIED);
Client.Send(new AccountTicketSuccessMessage());
TicketController.DestroyTicket(a_ticket);
Client.Account.loadData();
}
}
}
public void TicketEditTest()
{
var ac = new TicketController();
var r = ac.Edit(1) as ViewResult;
Assert.IsNotNull(r);
}
public void TicketCreateTest()
{
var tc = new TicketController();
var r = tc.Create() as ViewResult;
Assert.IsInstanceOfType(r, typeof(ViewResult));
}
/// <summary>
/// Method to update production XML and ticket status to ProductionReady
/// </summary>
public void UpdateTicketAndXMLForProduction()
{
string waitSettings = ConfigurationManager.AppSettings[Constants.SchedulerWaitTimeInMinutes];
int waitTime = Convert.ToInt32(waitSettings) * 60000; // 5 minute
while (true)
{
try
{
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + " ---------------------Started - EMIE Scheduler----------------------------");
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + " Fetching Scheduled requests...........");
TicketController ticketController = new TicketController();
List <Tickets> lstTickets = ticketController.GetTicketsDataByTicketStatus(TicketStatus.ProductionChangesScheduled);
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + String.Format(" Total tickets scheduled for prod changes are : {0}", lstTickets.Count));
//Console.WriteLine("Fetching Configuration settings for production changes...........");
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + " Fetching Configuration settings for production changes...........");
EMIEWebPortal.Models.Configuration config = null;
if (LoginController.config == null)
{
ConfigurationController configController = new ConfigurationController();
config = configController.GetConfiguration();
}
else
{
config = LoginController.config;
}
foreach (Tickets ticket in lstTickets)
{
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + String.Format(" Checking ticket #{0}", ticket.TicketId));
DateTime today = DateTime.Now;
DateTime ProdStartDate = ((DateTime)ticket.ScheduleDateTimeStart).ToLocalTime();
DateTime ProdEndDate = ((DateTime)ticket.ScheduleDateTimeEnd).ToLocalTime();
if (today >= ProdStartDate && ticket.FinalTicketStatus == TicketStatus.ProductionChangesScheduled)
{
// Console.WriteLine(string.Format("Processing ticket #{0}...........", ticket.TicketId));
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + String.Format(" Processing ticket #{0}...........", ticket.TicketId));
XMLHelper xmlHelper = new XMLHelper();
xmlHelper.OperationOnXML(ticket, Operation.AddInProduction, config);
ticketController.UpdateTicketStatus(ticket, TicketStatus.ProductionReady);
ticket.FinalTicketStatus = TicketStatus.ProductionReady;
CommonFunctions.SendMail(ticket, MailMessageType.ProductionChangesDoneThroughScheduler);
}
}
//Console.WriteLine("---------------------End - EMIE Scheduler----------------------------");
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + " ---------------------End - EMIE Scheduler----------------------------");
//// Sleep for 5 minute
File.AppendAllText(logFileName, String.Format("{0} ", Environment.NewLine) + DateTime.Now.ToString() + String.Format(" Wait for {0} milisecounds till the scheduler is called again", waitTime.ToString()));
}
catch (Exception ex)
{
File.AppendAllText(logFileName, ex.Message + DateTime.Now);
}
Thread.Sleep(waitTime);
}
}
public void DetailsShouldRenderViewDetailsWithCorrectModelId()
{
const int modelId = 5;
var ticketServiceMock = new Mock<ITicketService>();
ticketServiceMock.Setup(x => x.GetById(It.IsAny<int>()))
.Returns(value: new List<Ticket>() { new Ticket() }.AsQueryable());
var controller = new TicketController(ticketServiceMock.Object, null);
controller.WithCallTo(x => x.Details(modelId))
.ShouldRenderView("Details")
.WithModel<TicketDetailsViewModel>(
viewModel =>
{
Assert.AreEqual(modelId, viewModel.Id);
}).AndNoModelErrors();
}
public void GetTopOpenedShoudRednerPartialView_GetTopOpened()
{
var controller = new TicketController(null, null);
controller.WithCallTo(x => x.GetTopOpened())
.ShouldRenderPartialView("_GetTopOpened");
}
public static IController<TicketDto> GetTicketController()
{
if (TicketController == null)
{
TicketController = new TicketController();
}
return TicketController;
}
