public void CreatePost_WithNotValidModelState_ShouldReturnCorrectViewModel()
{
// Arrange
Mock <IDiscoveryService> discoveryService = new Mock <IDiscoveryService>();
Mock <IJournalService> journalService = new Mock <IJournalService>();
PublicationFormViewModel formModel = this.GetPublicationFormViewModel();
const int journalId = 1;
discoveryService
.Setup(d => d.DiscoveryDropdown(It.IsAny <int>()))
.Returns(this.GetDiscoveriesDropdown());
journalService
.Setup(j => j.GetName(It.IsAny <int>()))
.Returns(formModel.JournalName);
PublicationsController publicationsController = new PublicationsController(null, discoveryService.Object, journalService.Object, null);
publicationsController.ModelState.AddModelError(string.Empty, "Error");
// Act
IActionResult result = publicationsController.Create(journalId, formModel);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationFormViewModel>(model);
PublicationFormViewModel returnModel = model as PublicationFormViewModel;
this.AssertPublicationFormViewModel(formModel, returnModel);
}
public void Can_Paginate()
{
// Arrange
Mock <IPublicationRepositories> mock = new Mock <IPublicationRepositories>();
mock.Setup(m => m.publications).Returns((new Publication[] {
new Publication {
Id = 1, TypeId = 12, Status = "In Progress"
},
new Publication {
Id = 2, TypeId = 1, Status = "In Progress"
},
new Publication {
Id = 3, TypeId = 13, Status = "In Progress"
},
new Publication {
Id = 4, TypeId = 2, Status = "In Progress"
}
}).AsQueryable <Publication>());
PublicationsController controller = new PublicationsController(mock.Object);
//controller.PageSize = 3;
// Act
IEnumerable <Publication> result = controller.List().ViewData.Model as IEnumerable <Publication>;
// Assert
Publication[] prodArray = result.ToArray();
Assert.True(prodArray.Length == 4);
Assert.Equal("In Progress", prodArray[0].Status);
// Assert.Equal(13, prodArray[1].TypeId);
}
public void All_ShouldReturnView()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
ListPublicationsViewModel listModel = this.GetListPublicationsViewModel();
publicationService
.Setup(p => p.Total())
.Returns(20);
publicationService
.Setup(p => p.All(It.IsAny <int>(), It.IsAny <int>()))
.Returns(this.GetPublications());
PublicationsController publicationsController =
new PublicationsController(null, null, null, publicationService.Object, null);
// Act
IActionResult result = publicationsController.All(2);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <ListPublicationsViewModel>(model);
ListPublicationsViewModel returnModel = model as ListPublicationsViewModel;
this.AssertPages(listModel, returnModel);
this.AssertListPublicationsViewModel(listModel, returnModel);
}
public void Details_WithValidPublication_ShoudCallService(int value)
{
//1. Arrange:
bool serviceCalled = false;
var publicationModel = new PublicationViewModel()
{
Id = 1,
AuthorId = "111",
Title = "On the river with Tisho",
Description = "I was on the river with my friend Pesho and catched so many fishes with only one metal lure",
};
var mockService = new Mock <IBasePublicationsService>();
mockService
.Setup(service => service.GetPublication(value))
.Returns(publicationModel)
.Callback(() => serviceCalled = true);
var controller = new PublicationsController(mockService.Object);
//2.Act:
var result = controller.Details(1);
//3.Assert:
Assert.IsTrue(serviceCalled);
}
public void ByTelescope_WithNotExistingTelescopeId_ShouldReturnView()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITelescopeService> telescopeService = new Mock <ITelescopeService>();
ListPublicationsByTelescopeViewModel listModel = this.GetListPublicationsByTelescopeViewModel();
IEnumerable <ListPublicationsServiceModel> publications = null;
publicationService
.Setup(p => p.TotalByTelescope(It.IsAny <int>()))
.Returns(20);
publicationService
.Setup(p => p.AllByTelescope(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(publications);
telescopeService
.Setup(j => j.GetName(It.IsAny <int>()))
.Returns("Test Name");
PublicationsController publicationsController =
new PublicationsController(null, null, telescopeService.Object, publicationService.Object, null);
// Act
IActionResult result = publicationsController.ByTelescope(1, 2);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void EditPost_WithNotSuccessfullEdit_ShouldReturnBadRequest()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
const int journalId = 1;
PublicationFormServiceModel formModel = this.GetPublicationFormServiceModel();
publicationService
.Setup(p => p.GetTitle(It.IsAny <int>()))
.Returns(formModel.Title);
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(false);
publicationService
.Setup(p => p.Edit(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, null);
// Act
IActionResult result = publicationsController.Edit(journalId, formModel);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void Details_FoundedModel_ReturnsTheProperView(int value)
{
//1. Arrange:
var publicationModel = new PublicationViewModel()
{
Id = 1,
AuthorId = "111",
Title = "On the river with Tisho",
Description = "I was on the river with my friend Pesho and catched so many fishes with only one metal lure",
};
var mockService = new Mock <IBasePublicationsService>();
mockService
.Setup(service => service.GetPublication(value))
.Returns(publicationModel);
var controller = new PublicationsController(mockService.Object);
//2.Act:
var result = controller.Details(value);
//3.Assert:
Assert.IsInstanceOfType(result, typeof(ViewResult));
Assert.IsNotNull((result as ViewResult).Model);
}
public void EditGet_WithExistingPublicationId_ShouldReturnView()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
const int journalId = 1;
PublicationFormServiceModel formModel = this.GetPublicationFormServiceModel();
publicationService
.Setup(p => p.GetForm(It.IsAny <int>()))
.Returns(formModel);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, null);
// Act
IActionResult result = publicationsController.Edit(journalId);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationFormServiceModel>(model);
PublicationFormServiceModel returnModel = model as PublicationFormServiceModel;
this.AssertPublications(formModel, returnModel);
}
public void CreateGet_ShouldReturnCorrectViewModel()
{
// Arrange
Mock <IDiscoveryService> discoveryService = new Mock <IDiscoveryService>();
Mock <IJournalService> journalService = new Mock <IJournalService>();
PublicationFormViewModel formModel = this.GetPublicationFormViewModel();
const int journalId = 1;
discoveryService
.Setup(d => d.DiscoveryDropdown(It.IsAny <int>()))
.Returns(this.GetDiscoveriesDropdown());
journalService
.Setup(j => j.GetName(It.IsAny <int>()))
.Returns(formModel.JournalName);
PublicationsController publicationsController = new PublicationsController(null, discoveryService.Object, journalService.Object, null);
// Act
IActionResult result = publicationsController.Create(journalId);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationFormViewModel>(model);
PublicationFormViewModel returnModel = model as PublicationFormViewModel;
Assert.Equal(formModel.JournalName, returnModel.JournalName);
this.AssertDiscoveriesSelectList(returnModel.Discoveries);
}
public void CreatePost_WithExistingPublicationFromJournalForDiscovery_ShouldReturnCorrectViewModel()
{
// Arrange
Mock <IDiscoveryService> discoveryService = new Mock <IDiscoveryService>();
Mock <IJournalService> journalService = new Mock <IJournalService>();
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
PublicationFormViewModel formModel = this.GetPublicationFormViewModel();
const int journalId = 1;
const string discoveryName = "Fake Discovery Name";
discoveryService
.Setup(d => d.DiscoveryDropdown(It.IsAny <int>()))
.Returns(this.GetDiscoveriesDropdown());
discoveryService
.Setup(d => d.GetName(It.IsAny <int>()))
.Returns(discoveryName);
journalService
.Setup(j => j.GetName(It.IsAny <int>()))
.Returns(formModel.JournalName);
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(false);
publicationService
.Setup(p => p.Exists(It.IsAny <int>(), It.IsAny <int>()))
.Returns(true);
string errorMessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataErrorMessage] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, discoveryService.Object, journalService.Object, null);
publicationsController.TempData = tempData.Object;
// Act
IActionResult result = publicationsController.Create(journalId, formModel);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationFormViewModel>(model);
PublicationFormViewModel returnModel = model as PublicationFormViewModel;
this.AssertPublicationFormViewModel(formModel, returnModel);
Assert.Equal(string.Format(WebConstants.PublicationFromJournalExists, formModel.JournalName, discoveryName), errorMessage);
}
public void Details_WithValidId_ShouldReturnView()
{
// Arrange
Mock <ICommentService> commentService = new Mock <ICommentService>();
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
PublicationDetailsServiceModel detailsModel = this.GetPublicationDetailsServiceModel();
const int publicationId = 1;
commentService
.Setup(c => c.Total(publicationId))
.Returns(20);
commentService
.Setup(c => c.All(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <int?>()))
.Returns(this.GetComments());
publicationService
.Setup(p => p.Details(It.IsAny <int>()))
.Returns(detailsModel);
Mock <ClaimsPrincipal> claimsMock = new Mock <ClaimsPrincipal>();
claimsMock.Setup(t => t.Identity.IsAuthenticated)
.Returns(false);
Mock <HttpContext> mockHttpContext = new Mock <HttpContext>();
mockHttpContext.Setup(m => m.User).Returns(claimsMock.Object);
PublicationsController publicationsController =
new PublicationsController(commentService.Object, null, null, publicationService.Object, null)
{
ControllerContext = new ControllerContext
{
HttpContext = mockHttpContext.Object
}
};
// Act
IActionResult result = publicationsController.Details(publicationId, 2);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationDetailsViewModel>(model);
PublicationDetailsViewModel returnModel = model as PublicationDetailsViewModel;
this.AssertPublicationDetailsViewModel(this.GetPublicationDetailsViewModel(), returnModel);
}
public void CreatePost_WithSuccessfullyCreatedPublication_ShouldReturnRedirectResult()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
Mock <UserManager <User> > userManager = UserManagerMock.New;
const int journalId = 1;
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(false);
publicationService
.Setup(p => p.Exists(It.IsAny <int>(), It.IsAny <int>()))
.Returns(false);
publicationService
.Setup(p => p.Create(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(journalId);
userManager
.Setup(u => u.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns("1");
string successmessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataSuccessMessage] = It.IsAny <string>())
.Callback((string key, object message) => successmessage = message as string);
PublicationFormViewModel formModel = this.GetPublicationFormViewModel();
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, userManager.Object);
publicationsController.TempData = tempData.Object;
// Act
IActionResult result = publicationsController.Create(journalId, formModel);
// Assert
Assert.IsType <RedirectToActionResult>(result);
RedirectToActionResult redirectResult = result as RedirectToActionResult;
this.AssertRedirect(journalId, redirectResult);
Assert.Equal(string.Format(WebConstants.SuccessfullEntityOperation, Publication, WebConstants.Added), successmessage);
}
public void Details_WithNotValidId_ShouldReturnBadRequest()
{
// Arrange
Mock <ICommentService> commentService = new Mock <ICommentService>();
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
PublicationDetailsServiceModel detailsModel = null;
const int publicationId = 1;
commentService
.Setup(c => c.Total(publicationId))
.Returns(1);
publicationService
.Setup(p => p.Details(It.IsAny <int>()))
.Returns(detailsModel);
Mock <ClaimsPrincipal> claimsMock = new Mock <ClaimsPrincipal>();
claimsMock.Setup(t => t.Identity.IsAuthenticated)
.Returns(false);
Mock <HttpContext> mockHttpContext = new Mock <HttpContext>();
mockHttpContext
.Setup(m => m.User)
.Returns(claimsMock.Object);
PublicationsController publicationsController =
new PublicationsController(commentService.Object, null, null, publicationService.Object, null)
{
ControllerContext = new ControllerContext
{
HttpContext = mockHttpContext.Object
}
};
// Act
IActionResult result = publicationsController.Details(publicationId, 1);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void EditPost_WithNewExistingTitle_ShouldReturnCorrectView()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
const int journalId = 1;
PublicationFormServiceModel formModel = this.GetPublicationFormServiceModel();
publicationService
.Setup(p => p.GetTitle(It.IsAny <int>()))
.Returns(formModel.Title);
formModel.Title = "New Title";
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(true);
string errorMessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataErrorMessage] = It.IsAny <string>())
.Callback((string key, object message) => errorMessage = message as string);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, null);
publicationsController.TempData = tempData.Object;
// Act
IActionResult result = publicationsController.Edit(journalId, formModel);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <PublicationFormServiceModel>(model);
PublicationFormServiceModel returnModel = model as PublicationFormServiceModel;
this.AssertPublications(formModel, returnModel);
Assert.Equal(string.Format(WebConstants.EntryExists, Publication), errorMessage);
}
public void EditGet_WithNotExistingPublicationId_ShouldReturnBadRequest()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
const int journalId = 1;
PublicationFormServiceModel formModel = null;
publicationService
.Setup(p => p.GetForm(It.IsAny <int>()))
.Returns(formModel);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, null);
// Act
IActionResult result = publicationsController.Edit(journalId);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void EditPost_WithSuccessfullEdit_ShouldReturnRedirectResult()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITempDataDictionary> tempData = new Mock <ITempDataDictionary>();
const int journalId = 1;
PublicationFormServiceModel formModel = this.GetPublicationFormServiceModel();
publicationService
.Setup(p => p.GetTitle(It.IsAny <int>()))
.Returns("Fake Title");
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(false);
publicationService
.Setup(p => p.Edit(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
string successmessage = null;
tempData
.SetupSet(t => t[WebConstants.TempDataSuccessMessage] = It.IsAny <string>())
.Callback((string key, object message) => successmessage = message as string);
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, null);
publicationsController.TempData = tempData.Object;
// Act
IActionResult result = publicationsController.Edit(journalId, formModel);
// Assert
Assert.IsType <RedirectToActionResult>(result);
RedirectToActionResult redirectResult = result as RedirectToActionResult;
this.AssertRedirect(journalId, redirectResult);
Assert.Equal(string.Format(WebConstants.SuccessfullEntityOperation, Publication, WebConstants.Edited), successmessage);
}
public void CreatePost_WithNotSuccessfullyCreatedPublication_ShouldReturnBadRequest()
{
// Arrange
Mock <IJournalService> journalService = new Mock <IJournalService>();
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <UserManager <User> > userManager = UserManagerMock.New;
const int journalId = 1;
publicationService
.Setup(p => p.TitleExists(It.IsAny <string>()))
.Returns(false);
publicationService
.Setup(p => p.Exists(It.IsAny <int>(), It.IsAny <int>()))
.Returns(false);
publicationService
.Setup(p => p.Create(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <int>()))
.Returns(-1);
userManager
.Setup(u => u.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns("1");
PublicationFormViewModel formModel = this.GetPublicationFormViewModel();
PublicationsController publicationsController = new PublicationsController(publicationService.Object, null, null, userManager.Object);
// Act
IActionResult result = publicationsController.Create(journalId, formModel);
// Assert
Assert.IsType <BadRequestResult>(result);
}
public void Details_RetursCorrectModelInformation()
{
// 1.
var service = new Mock <IBasePublicationsService>();
var controller = new PublicationsController(service.Object);
var publicationModel = new PublicationViewModel()
{
Id = 1,
AuthorId = "111",
Title = "On the river with Tisho",
Description = "I was on the river with my friend Pesho and catched so many fishes with only one metal lure",
};
service.Setup(serv => serv.GetPublication(publicationModel.Id))
.Returns(new PublicationViewModel()
{
Id = publicationModel.Id,
AuthorId = publicationModel.AuthorId,
Title = publicationModel.Title,
Description = publicationModel.Description
});
// 2. Act:
var result = controller.Details(publicationModel.Id);
//3. Assert:
var resultModel = result as ViewResult;
Assert.IsNotNull(resultModel.Model);
Assert.IsInstanceOfType(resultModel.Model, typeof(PublicationViewModel));
var productType = (resultModel.Model as PublicationViewModel);
Assert.AreEqual(publicationModel.Id, productType.Id);
Assert.AreEqual(publicationModel.AuthorId, productType.AuthorId);
Assert.AreEqual(publicationModel.Title, productType.Title);
Assert.AreEqual(publicationModel.Description, productType.Description);
}
public void ByTelescope_ShouldReturnView()
{
// Arrange
Mock <IPublicationService> publicationService = new Mock <IPublicationService>();
Mock <ITelescopeService> telescopeService = new Mock <ITelescopeService>();
ListPublicationsByTelescopeViewModel listModel = this.GetListPublicationsByTelescopeViewModel();
publicationService
.Setup(p => p.TotalByTelescope(It.IsAny <int>()))
.Returns(20);
publicationService
.Setup(p => p.AllByTelescope(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()))
.Returns(this.GetPublications());
telescopeService
.Setup(j => j.GetName(It.IsAny <int>()))
.Returns("Journal Name");
PublicationsController publicationsController =
new PublicationsController(null, null, telescopeService.Object, publicationService.Object, null);
// Act
IActionResult result = publicationsController.ByTelescope(1, 2);
// Assert
Assert.IsType <ViewResult>(result);
object model = (result as ViewResult).Model;
Assert.IsType <ListPublicationsByTelescopeViewModel>(model);
ListPublicationsByTelescopeViewModel returnModel = model as ListPublicationsByTelescopeViewModel;
this.AssertPages(listModel, returnModel);
this.AssertListPublicationsByTelescopeViewModel(listModel, returnModel);
}
public WebApiTestPublication()
{
creator = new CreatePublication();
controller = new PublicationsController();
}
private void researchersListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (e.AddedItems.Count > 0)
{
researcher = (Researcher)e.AddedItems[0];
researcher = rc.LoadResearcherDetails(researcher);
ResearcherDetailsPanel.DataContext = researcher;
//Show past positions
positionsListView.Items.Clear();
foreach (var p in researcher.positions)
{
if (researcher.position.Level != EmploymentLevel.Student && p.End != default(DateTime))
{
positionsListView.Items.Add(p.Start + "\t" + p.End + "\t" + p.Title() + Environment.NewLine);
}
}
staff = new Staff(researcher);
rc.GetViewableStudents();
students = rc.VisibleStudents.ToList();
if (researcher.position.Level != EmploymentLevel.Student)
{
threeYear.Content = staff.ThreeYearAverage;
performance.Content = staff.PerformancePercentage;
supervisions.Content = staff.Supervisions;
}
else
{
threeYear.Content = null;
performance.Content = null;
supervisions.Content = null;
}
if (researcher.position.Level == EmploymentLevel.Student)
{
Student student = (from s in students
where researcher.ID == s.ID
select s).SingleOrDefault();
degree.Content = student.Degree;
researchers = rc.VisibleResearchers.ToList();
var supervisor = (from s in researchers
where s.ID == student.SupervisorID
select s).SingleOrDefault();
supervisors.Content = supervisor.GivenName + " " + supervisor.FamilyName;
}
else
{
degree.Content = null;
supervisors.Content = null;
}
//Show publications
pc = new PublicationsController(researcher);
pc.SortPublicationList();
publications = pc.VisiblePublications.ToList();
publicationsListView.ItemsSource = publications;
}
}
static void Main(string[] args)
{
string response;
Control.ResearcherController R_Controller = new ResearcherController();
Control.PublicationsController P_controller = new PublicationsController();
Researcher.Researcher res;
int id;
R_Controller.LoadReseachers();
do
{
R_Controller.basicConsoleDisplay().ForEach(Console.WriteLine);
Console.WriteLine("Would you like to a) exit, b) filter by name, c) filter by level, d) reset, e) sort ascending, f) sort descending, g) more info");
response = Console.ReadLine();
//Should have used switch but anyway :-)
if (response == "a")
{
}
else if (response == "b")
{
Console.WriteLine("Please enter name: ");
R_Controller.FilterByName(Console.ReadLine());
}
else if (response == "c")
{
Console.WriteLine("Please enter Employment Level: ");
R_Controller.FilterBy((Researcher.EmploymentLevel)Enum.Parse(typeof(Researcher.EmploymentLevel), Console.ReadLine()));
}
else if (response == "d")
{
R_Controller.reset();
}
else if (response == "e")
{
R_Controller.sortAlphabetically(true);
}
else if (response == "f")
{
R_Controller.sortAlphabetically(false);
}
else if (response == "g")
{
Console.WriteLine("Please enter ID: ");
id = Int32.Parse(Console.ReadLine());
R_Controller.LoadResearcherDetails(id);
R_Controller.researcherConsoleDisplay().ForEach(Console.WriteLine);
Console.WriteLine("Press a) to exit or b) to display publications: ");
if (Console.ReadLine() == "b")
{
if (R_Controller.isStaff)
{
res = (Researcher.Researcher)R_Controller.staff;
}
else
{
res = (Researcher.Researcher)R_Controller.student;
}
P_controller.loadPublications(res);
P_controller.basicPublicationConsole().ForEach(Console.WriteLine);
Console.WriteLine("Press a) to exit or b) to view detailed publication");
if (Console.ReadLine() == "b")
{
Console.WriteLine("Please enter number: ");
id = int.Parse(Console.ReadLine());
P_controller.loadFullPublications(P_controller.displayList.ToArray()[id]);
P_controller.fullPublicationConsole().ForEach(Console.WriteLine);
Console.WriteLine("Press enter to continue");
Console.ReadLine();
}
}
}
} while (response != "a");
}
