public async Task <IActionResult> AssertionConsumerService()
{
// Receive and process the SAML assertion contained in the SAML response.
// The SAML response is received either as part of IdP-initiated or SP-initiated SSO.
var ssoResult = await _samlServiceProvider.ReceiveSsoAsync();
if (string.IsNullOrEmpty(ssoResult.RelayState))
{
// This was a test initiated from the manage page
return(RedirectToAction("Index", "Manage", new { Message = ManageController.ManageMessageId.TestSamlSuccess }));
}
// This is a mess, but there's no other way to find the current user because
// this controller hides the current identity for some reason
var user = await _userManager.FindByIdAsync(ssoResult.RelayState.Split(',')[0]);
var universityService = new UniversityService(new SqlUniversityRepository(_dbContext));
var university = await universityService.FindByIdAsync(int.Parse(ssoResult.RelayState.Split(',')[1]));
var authConfigService = new AuthConfigService(new SqlAuthConfigRepository(_dbContext), null);
var authConfig = await authConfigService.GetConfigAsync(university);
await universityService.JoinAsync(user, university, authConfig.OverrideUsernames?ssoResult.UserID : null);
return(RedirectToAction("Index", "Chat"));
}
public AdminController(dbcontext context)
{
uS = new UserService(context);
fS = new FacultyService(context);
unvS = new UniversityService(context);
_context = context;
}
public ChatController(WarblerDbContext context)
{
UserService = new UserService(new SqlUserRepository(context));
UniversityService = new UniversityService(new SqlUniversityRepository(context));
AuthConfigService = new AuthConfigService(new SqlAuthConfigRepository(context), null);
ChannelTemplateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
}
public async Task <IActionResult> University(AuthConfig config)
{
if (!ModelState.IsValid)
{
config.University = await GetClaimedUniversity(await GetCurrentUserAsync(), config.UniversityId);
return(View("ManageUniversity", config));
}
var authConfigService = new AuthConfigService(new SqlAuthConfigRepository(_dbContext), _samlConfigurations);
await authConfigService.SaveAsync(config);
var universityService = new UniversityService(new SqlUniversityRepository(_dbContext));
var claimedUniversity = await universityService.FindByIdAsync(config.UniversityId);
var serverService = new ServerService(new SqlServerRepository(_dbContext));
await serverService.EnableAuthAsync(claimedUniversity.Server);
var membershipService = new MembershipService(new SqlMembershipRepository(_dbContext));
foreach (var channel in claimedUniversity.Server.Channels)
{
await membershipService.DropMembershipsAsync(channel);
}
return(RedirectToAction(nameof(Index), new { Message = ManageMessageId.ManageUniversitySuccess }));
}
public HomeController(dbcontext context)
{
uS = new UserService(context);
unvS = new UniversityService(context);
fS = new FacultyService(context);
sS = new SubjectService(context);
qS = new QuestionService(context);
}
public async Task ResolveClaim([FromBody] ClaimRequest claim)
{
if (claim.IsAccepted ?? false)
{
await UniversityService.ApplyClaimAsync(claim.University, claim.SubmitterId);
}
await ClaimRequestService.UpdateAsync(claim);
}
public async Task AllQueryable_Message_Should_Get_Everything()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var testUni = new UniversityService(repo);
var universities = await testUni.GetAllAsync();
Assert.IsNotNull(universities.First());
Assert.IsNotNull(universities.First().Server);
Assert.IsNotNull(universities.First().Server.Channels);
Assert.IsNotNull(universities.First().Server.Channels.First().Users);
Assert.IsNotNull(universities.First().Server.Channels.First().Messages);
}
}
public IActionResult SaveUniversity(University university)
{
try
{
var Response = new UniversityService(studentContext).SaveUniversity(university);
if (Response)
{
return(Ok("University Saved!!!"));
}
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IActionResult GetUniversities()
{
try
{
var Data = new UniversityService(studentContext).GetUniversities();
if (Data != null)
{
return(Ok(Data));
}
return(NotFound());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void GetAllWithSpecialitiesAsync_ShouldReturnRightNumberOfSpecialities()
{
//arrange
var expected = GetUniversitiesWithSpecielitiesDTO().ToList();
_uowMock.Setup(e => e.UniversityRepository.GetAllAsync().Result).Returns(GetUniversitiesWithSpecielitiesDAO());
//act
_sut = new UniversityService(_uowMock.Object, UTestHelper.CreateMapper());
var actual = _sut.GetAllAsync().Result.ToList();
//assert
foreach (var expectedItem in expected)
{
Assert.AreEqual(expectedItem.Specialities.Count, actual.Single(e => e.Id == expectedItem.Id).Specialities.Count);
}
}
public void GetAllWithSpecialitiesAsync_ShouldReturnAllUniversities()
{
//arrange
var expected = GetUniversitiesWithSpecielitiesDTO().ToList();
_uowMock.Setup(e => e.UniversityRepository.GetAllAsync().Result).Returns(GetUniversitiesWithSpecielitiesDAO());
//act
IUniversityService universiryService = new UniversityService(_uowMock.Object, UTestHelper.CreateMapper());
var actual = universiryService.GetAllAsync().Result.ToList();
//assert
for (int i = 0; i < actual.Count; i++)
{
Assert.AreEqual(expected[i].Id, actual[i].Id);
Assert.AreEqual(expected[i].Name, actual[i].Name);
Assert.AreEqual(expected[i].ShortName, actual[i].ShortName);
}
}
public async Task JoinAsync_Should_Have_Users_Join_All_Channels_In_A_University()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var test = new UniversityService(repo);
var newUser = new User {
UserName = "******"
};
var testUni = await repo.LookupAsync
(context.Universities.FirstOrDefault
(u => u.Name == "Test").PlaceId);
//Assert.AreEqual(2, context.Universities.Count());
await test.JoinAsync(newUser, testUni);
var testUser = context.Users.FirstOrDefault(u => u.UserName == "Bill");
Assert.AreEqual(testUni.Server.Channels.Count(), testUser.Channels.Count());
}
}
public async Task <string> Join([FromBody] NearByResult userChoice)
{
var user = await UserService.FindByNameAsync(User.Identity.Name);
var university = await UniversityService.GetOrCreateAsync(userChoice, await ChannelTemplateService.GetAsync());
var isAlreadyMember = university.Server.Channels
.Any(ch => ch.Memberships.Any(m => m.User.Equals(user)));
if (isAlreadyMember)
{
return("/Chat");
}
if (university.Server.IsAuthEnabled)
{
var partner = await AuthConfigService.GetConfigAsync(university);
return($"/Account/SingleSignOn?partnerName={partner.Name}&relayState={user.Id},{university.Id}");
}
await UniversityService.JoinAsync(user, university);
return("/Chat");
}
public async Task GetOrCreateAsync_Should_Create_A_New_University()
{
using (var context = new WarblerDbContext(Options))
{
var repo = new SqlUniversityRepository(context);
var test = new UniversityService(repo);
var nearbyResult = new NearByResult
{
Name = "NewUni",
Geometry = new Geometry {
Location = new Location(1.0, 1.0)
}
};
var templateService = new ChannelTemplateService(new SqlChannelTemplateRepository(context));
await templateService.CreateDefaultTemplatesAsync();
var uniTest = await test.GetOrCreateAsync(nearbyResult, await templateService.GetAsync());
//Assert.AreEqual(2, context.Universities.Count());
Assert.AreEqual("NewUni", uniTest.Name);
}
}
public async Task <IActionResult> DeleteUniversityAsync(int universityId)
{
await UniversityService.DeleteAsync(await UniversityService.FindByIdAsync(universityId));
return(RedirectToAction("Index"));
}
public PeopleController()
{
stService = new PeopleService();
unServise = new UniversityService();
}
public FacultiesController(dbcontext context)
{
uS = new UserService(context);
fS = new FacultyService(context);
unvS = new UniversityService(context);
}
public FacultiesAPIController(dbcontext context)
{
fS = new FacultyService(context);
uS = new UniversityService(context);
sS = new SubjectService(context);
}
public UniversityController(AppDbContext context)
{
_context = context;
universityService = new UniversityService(_context);
}
public AttributeController()
{
_universityService = new UniversityService();
_studentService = new StudentService();
}
public UniversityAPIController(dbcontext context)
{
uS = new UniversityService(context);
}
public UniversController(dbcontext context)
{
unvS = new UniversityService(context);
uS = new UserService(context);
}
public DevController(WarblerDbContext context)
{
UniversityService = new UniversityService(new SqlUniversityRepository(context));
ClaimRequestService = new ClaimRequestService(new SqlClaimRequestRepository(context));
}
public async Task <string> Universities()
{
var universityList = await UniversityService.GetAllAsync();
return(JsonConvert.SerializeObject(universityList, Formatting.Indented));
}
