public AcademicController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
_studentServices = studentServices;
_systemServices = systemServices;
_studentCredentials = new StudentCredential(context, studentServices, systemServices);
}
public ExamCardController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
_studentServices = studentServices;
studentCredentials = new StudentCredential(_context, studentServices, systemServices);
_financeUtilities = new FinanceController(context, studentServices, systemServices);
}
public HostelBookingController(UnisolAPIdbContext context, IStudentServices studentServices,
ISystemServices systemServices, IConfiguration configuration)
{
_context = context;
_systemServices = systemServices;
_configuration = configuration;
_studentServices = studentServices;
studentCredentials = new StudentCredential(_context, studentServices, systemServices);
}
public UnitsController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
_studentServices = studentServices;
_systemServices = systemServices;
studentCredentials = new StudentCredential(context, studentServices, systemServices);
campusDetails = new CampusDetails(context);
_financeUtilities = new FinanceController(context, studentServices, systemServices);
}
public Campus360AcademicsController(UnisolAPIdbContext context, IPortalApiProxy portalProxy, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
studentCredentials = new StudentCredential(context, studentServices, systemServices);
_studentServices = studentServices;
_systemServices = systemServices;
campusDetails = new CampusDetails(context);
_portalProxy = portalProxy;
}
private async Task <IActionResult> HandleUpstreamFailoverAsync(StudentCredential credential, string successMessage, string failMessage, ILogger log)
{
log.LogWarning("Experiencing issues with upstream service.");
DataAccessResult <StudentCredential> credentialFetchResult = await dataService.GetCredentialAsync(credential.StudentId);
if (credentialFetchResult.Success)
{
if (credential.PasswordHash.Equals(credentialFetchResult.Resource.PasswordHash, StringComparison.Ordinal))
{
string token = tokenService.CreateToken(credential.StudentId);
return(new OkObjectResult(new BackendResult <AccessToken>(true, AccessToken.CompletedToken(token), successMessage)));
}
else
{
return(new UnauthorizedObjectResult(new BackendResult <AccessToken>(locService.GetString("CredentialErrorCannotSignIn"))));
}
}
else
{
return(new UnauthorizedObjectResult(new BackendResult <AccessToken>(failMessage)));
}
}
public void DecryptCredential(StudentCredential credential)
{
if (credential.Iv == null)
{
throw new ArgumentException("Missing IV in provided credential.");
}
using (Aes aes = Aes.Create())
{
aes.Key = key;
aes.IV = Convert.FromBase64String(credential.Iv);
using (var encryptedStream = new MemoryStream(Convert.FromBase64String(credential.PasswordHash)))
{
using (var cryptoStream = new CryptoStream(encryptedStream, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
using (var reader = new StreamReader(cryptoStream))
{
credential.PasswordHash = reader.ReadToEnd();
}
}
}
}
credential.Iv = null;
}
public void EncryptCredential(StudentCredential credential)
{
if (credential.Iv != null)
{
throw new InvalidOperationException("IV is not empty. Possibly already encrypted.");
}
using (Aes aes = Aes.Create())
{
aes.Key = key;
credential.Iv = Convert.ToBase64String(aes.IV);
using (var encryptedStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(encryptedStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
using (var writer = new StreamWriter(cryptoStream))
{
writer.Write(credential.PasswordHash);
}
}
credential.PasswordHash = Convert.ToBase64String(encryptedStream.ToArray());
}
}
}
public async Task <DataRequestResult <AccessToken> > SignInAsync(StudentCredential credential, bool createAccount = false)
{
_ = credential?.StudentId ?? throw new InvalidOperationException("User credential is not yet configured.");
_ = credential?.PasswordHash ?? throw new InvalidOperationException("User credential is not yet configured.");
try
{
HttpResponseMessage response = await client.PostAsync($"signIn/{createAccount}", new JsonStringContent(credential));
if (response.StatusCode == HttpStatusCode.OK || response.StatusCode == HttpStatusCode.Accepted)
{
var result = await response.Content.ReadAsJsonObjectAsync <BackendResult <AccessToken> >();
credentialService.Token = result.Resource.Token;
return(new DataRequestResult <AccessToken>(result.Resource, result.Message));
}
else
{
BackendRequestFailedException exception;
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
exception = new BackendAuthenticationFailedException("Request failed due to incorrect credentials. Endpoint: signIn.");
}
else
{
exception = new BackendRequestFailedException($"Request failed due to an unexpected response status {response.StatusCode}. Endpoint: signIn.");
}
exception.DisplayMessage = await GetBackendMessageAsync(response.Content);
throw exception;
}
}
catch (Exception ex) when(ex is HttpRequestException || ex is TaskCanceledException)
{
throw GetDefaultException($"signIn", ex);
}
}
public ElectionsController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
studentCredentials = new StudentCredential(context, studentServices, systemServices);
}
public TranscriptController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemRepository)
{
_context = context;
studentCredential = new StudentCredential(context, studentServices, systemRepository);
}
public FinanceController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
studentCredentials = new StudentCredential(_context, studentServices, systemServices);
}
public async Task <DataAccessResult> SetCredentialAsync(StudentCredential credential)
{
encryptionService.EncryptCredential(credential);
return(await SetResourceAsync(credential));
}
public async Task <IActionResult> RunPost(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "Calendar")] HttpRequest req,
[UserIdentity] string?username,
ILogger log)
{
if (username == null)
{
return(new UnauthorizedResult());
}
DataAccessResult <StudentInfo> userFetchResult = await dataService.GetStudentInfoAsync(username);
StudentInfo?info = null;
if (userFetchResult.Success)
{
info = userFetchResult.Resource;
}
else if (userFetchResult.StatusCode == 404)
{
DataAccessResult <StudentCredential> credentialFetchResult = await dataService.GetCredentialAsync(username);
if (credentialFetchResult.Success)
{
try
{
StudentCredential credential = credentialFetchResult.Resource;
SignInContext signInContext = await client.SignInAsync(credential.StudentId, credential.PasswordHash);
info = await client.GetStudentInfoAsync(signInContext);
}
catch (Exception ex)
{
log.LogError(ex, "Failed to fetch sign in or fetch user info from upstream.");
}
}
else if (credentialFetchResult.StatusCode == 404)
{
return(new UnauthorizedResult());
}
else
{
log.LogError("Failed to fetch user credential. Status {statusCode}", credentialFetchResult.StatusCode);
}
}
else
{
log.LogError("Failed to fetch user info from database. Status {statusCode}", userFetchResult.StatusCode);
}
if (info == null)
{
return(new ObjectResult(new BackendResult <CalendarSubscription>(locService.GetString("ServiceErrorCannotAddCalendarSub")))
{
StatusCode = 503
});
}
info.CalendarSubscriptionId = Guid.NewGuid().ToString();
DataAccessResult userUpdateResult = await dataService.SetStudentInfoAsync(info);
if (userUpdateResult.Success)
{
return(new OkObjectResult(new BackendResult <CalendarSubscription>(new CalendarSubscription(info.CalendarSubscriptionId))));
}
else
{
log.LogError("Failed to update user info. Status {statusCode}", userUpdateResult.StatusCode);
return(new ObjectResult(new BackendResult <CalendarSubscription>(locService.GetString("ServiceErrorCannotAddCalendarSub")))
{
StatusCode = 503
});
}
}
public OnlineReportingController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
_studentServices = studentServices;
studentCredentials = new StudentCredential(context, studentServices, systemServices);
}
public LibraryController(LibraryAPIdbContext libraryContext, UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_libraryContext = libraryContext;
studentCredentials = new StudentCredential(context, studentServices, systemServices);
library = new Library(libraryContext);
}
public DatabaseUtilitiesController(UnisolAPIdbContext context, IStudentServices studentServices, ISystemServices systemServices)
{
_context = context;
_studentServices = studentServices;
studentCredentials = new StudentCredential(_context, studentServices, systemServices);
}
public async Task HandleRequestAsync <T>(
string username,
Func <IDataAccessService, Task <DataAccessResult <T> > > databaseFetchTask,
Func <IUcquClient, SignInContext, Task <T> > clientFetchTask,
Func <IDataAccessService, T, Task <DataAccessResult> > updateTask,
Func <T?, T, bool> shouldUpdate,
Func <T?, T, Task>?updateCompleteCallback,
ILogger log)
where T : class, IStatusResource
{
// Fetch new version.
Task <DataAccessResult <T> > oldFetchTask = databaseFetchTask(dataService);
RecordStatus newStatus = RecordStatus.UpToDate;
DataAccessResult <StudentCredential> credentialFetchResult = await dataService.GetCredentialAsync(username);
T?newResource = default(T);
if (credentialFetchResult.Success)
{
// Got credential.
StudentCredential credential = credentialFetchResult.Resource;
try
{
SignInContext signInContext = await client.SignInAsync(credential.StudentId, credential.PasswordHash);
if (signInContext.IsValid)
{
// OK.
newResource = await clientFetchTask(client, signInContext);
}
else
{
// User changed password. Mark stale.
newStatus = RecordStatus.StaleAuthError;
}
}
catch (Exception ex)
{
// New resource fetch failure. Mark stale.
log.LogError(ex, "Failed to sign in or fetch resource from upstream. Resource type {resourceType}", typeof(T));
newStatus = RecordStatus.StaleUpstreamError;
}
}
else if (credentialFetchResult.StatusCode == 404)
{
// Credential lost. Mark stale.
log.LogWarning("Credential not found. Resource type {resourceType}", typeof(T));
newStatus = RecordStatus.StaleAuthError;
}
else
{
// Data access error. Skip this refresh.
log.LogError("Failed to fetch credential. Resource type {resourceType}. Status {statusCode}", typeof(T), credentialFetchResult.StatusCode);
return;
}
// End new version fetch.
// As of now, either new version contains value, or stale status determined.
// Fetch old version.
T?oldResource = default(T);
DataAccessResult <T> oldFetchResult = await oldFetchTask;
if (oldFetchResult.Success)
{
// OK.
oldResource = oldFetchResult.Resource;
}
else if (oldFetchResult.StatusCode != 404)
{
// Data access error.
log.LogError("Failed to fetch resource from database. Resource type {resourceType}. Status {statusCode}", typeof(T), oldFetchResult.StatusCode);
return;
}
// End old version fetch.
// As of now, either old version contains value, or an old version really does not exist.
// Compare and update.
if (newResource == null && oldResource == null)
{
// Both new and old resources are missing. Skip for this time.
log.LogWarning("Update skipped because both old and new resources are missing. Resource type {resourceType}.", typeof(T));
return;
}
else if (newResource == null)
{
// New resource cannot be fetched. Update stale flag.
oldResource !.RecordStatus = newStatus;
DataAccessResult updateResult = await updateTask(dataService, oldResource);
if (!updateResult.Success)
{
log.LogError("Failed to update database. Resource type {resourceType}. Status {statusCode}", typeof(T), updateResult.StatusCode);
}
return;
}
else if (shouldUpdate(oldResource, newResource))
{
// Caller determined that the resource should be updated.
DataAccessResult updateResult = await updateTask(dataService, newResource);
if (updateResult.Success)
{
if (updateCompleteCallback != null)
{
try
{
await updateCompleteCallback(oldResource, newResource);
}
catch (Exception ex)
{
log.LogWarning(ex, "Update completion callback ran into an error.");
}
}
}
else
{
log.LogError("Failed to update database. Resource type {resourceType}. Status {statusCode}", typeof(T), updateResult.StatusCode);
}
return;
}
else if (oldResource != null && oldResource.RecordStatus != RecordStatus.UpToDate)
{
// Caller opted to not update, but stale flag has to be cleared.
oldResource.RecordStatus = RecordStatus.UpToDate;
DataAccessResult updateResult = await updateTask(dataService, oldResource);
if (!updateResult.Success)
{
log.LogError("Failed to update database. Resource type {resourceType}. Status {statusCode}", typeof(T), updateResult.StatusCode);
}
return;
}
}
public CoursesController(IStudentServices studentServices, UnisolAPIdbContext context, ISystemServices systemService)
{
_studentServices = studentServices;
_context = context;
_studentCredentials = new StudentCredential(_context, studentServices, systemService);
}
