public JsonResult GetEClaims(string userCode, string searchText)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Staff)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to perform this action",
}));
}
var createResults = _unisolApiProxy.GetEClaims(userCode, searchText).Result;
var jdata = JsonConvert.DeserializeObject <ReturnData <dynamic> >(createResults);
return(Json(jdata));
}
public JsonResult SaveExaminationLogging(ExaminationLog examinationLog)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
_context.ExaminationLogs.Add(examinationLog);
_context.SaveChanges();
return(Json(new ReturnData <string>
{
Success = true,
Message = "Logs save successfully"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "There was a problem when saving logs " + ex.Message
}));
}
}
public JsonResult AddNewsViews()
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
return(Json(new ReturnData <string>
{
Success = true,
Message = "Successful"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occurred,please retry : " + ex.Message
}));
}
}
public JsonResult GetUserRequests(string userCode, string searchText)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Staff)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to perform this action",
}));
}
var surrenderReqs = new List <ImprestSurrenderReq>();
try
{
surrenderReqs = _context.ImprestSurrenderReqs.Where(m => m.PayeeRef.Equals(userCode)).OrderByDescending(m => m.DateModified)
.ThenBy(m => m.ImpRef).ToList();
foreach (var surReq in surrenderReqs)
{
if (surReq.Status)
{
continue;
}
if (_unisolContext.ImprestSur.Any(m => m.ImpRef.Equals(surReq.ImpRef)))
{
surReq.Status = true;
_context.SaveChanges();
}
}
return(Json(new ReturnData <List <ImprestSurrenderReq> >
{
Success = true,
Data = surrenderReqs,
Message = "user surrender requests retrieved"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <List <ImprestSurrenderReq> >
{
Success = false,
Data = surrenderReqs,
Message = "Error occurred while processing your request"
}));
}
}
public JsonResult GetStudentFeeStatement(string usercode)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Student)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to view this page",
}));
}
var statementResult = _unisolApiProxy.GetStudentFeeStatement(usercode, classStatus).Result;
var jdata = new ProcessJsonReturnResults <dynamic>(statementResult).UnisolApiData;
return(Json(jdata));
}
public JsonResult Create(Settings request)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var requiredFields = new List <Tuple <string, string, DataType> >
{
Tuple.Create("name", request.Name, DataType.Default),
Tuple.Create("address", request.Name, DataType.Default),
Tuple.Create("themeColor", request.ThemeColor, DataType.Default),
};
var validation = _validateService.Validate(requiredFields);
if (!validation.Valid)
{
return(Json(new ReturnData <string>
{
Message = validation.Errors,
Success = false
}));
}
if (request.Id > 0)
{
_context.Settings.Update(request);
}
else
{
_context.Settings.Add(request);
}
_context.SaveChanges();
return(Json(new ReturnData <string>
{
Success = true,
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occured, please try again",
Error = new Error(ex)
}));
}
}
public void ShouldThrowExceptionWhenTokenIsNotValid()
{
_audience = "";
CreateToken();
Assert.Throws <ForbiddenException>(
() => _jwtValidation.Validate(_userJwt, TokenType.Access),
"Token failed validation.");
}
public JsonResult AddSection(EvaluationSectionViewModel evaluationSectionViewModel)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (!string.IsNullOrEmpty(evaluationSectionViewModel.SectionName))
{
var evaluationSection = new EvaluationSection
{
SectionName = evaluationSectionViewModel.SectionName,
EvaluationId = evaluationSectionViewModel.EvaluationId,
EvaluationQuestions = evaluationSectionViewModel.EvaluationQuestions
};
if (evaluationSectionViewModel.Id.HasValue && evaluationSectionViewModel.Id.Value > 0)
{
evaluationSection.Id = (int)evaluationSectionViewModel.Id;
_context.EvaluationSections.Update(evaluationSection);
}
else
{
_context.EvaluationSections.Add(evaluationSection);
}
_context.SaveChangesAsync();
return(Json(new ReturnData <string>
{
Success = true,
Message = "Section name saved successfully"
}));
}
return(Json(new ReturnData <string>
{
Success = false,
Message = "Section name cannot be empty"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occurred,please retry : " + ex.Message
}));
}
}
public JsonResult OnlineReporting(string usercode, string searchString = "", int offset = 1)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Student)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to access this page",
}));
}
var onlineReporting = _unisolApiProxy.GetOnlineReporting(usercode, classStatus).Result;
var jdata = new ProcessJsonReturnResults <List <ReportingViewModel> >(onlineReporting).UnisolApiData;
if (jdata.Success)
{
return(Json(new ReturnData <List <ReportingViewModel> >
{
Success = true,
Message = jdata.Message,
Data = jdata.Data
}));
}
return(Json(new ReturnData <bool>
{
Success = false,
Message = jdata.Message
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occured while trying to get Hostels, please try again " + ex.Message
}));
}
}
public JsonResult GetAcademicYears()
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetAcademicYears().Result;
var response = new ProcessJsonReturnResults <List <SectionSearch> >(result).UnisolApiData;
if (response.Success)
{
return(Json(response));
}
return(Json(new ReturnData <SectionSearch>
{
Success = false,
Message = response.Message
}));
}
public JsonResult GetDashboardContent(string searchText, int?offset = null, int?itemsPerPage = null, int?role = null)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
switch (3)
{
case (int)Role.Admin:
var admin = "";
break;
case (int)Role.Staff:
var staff = "";
break;
case (int)Role.Student:
var student = "";
break;
default:
var defaultAction = "";
break;
}
var response = _portalServices.FilterUsers(searchText, offset, itemsPerPage, role);
return(Json(response));
}
/// <summary>
/// Adds Clash of Clans services to the service collection. The registered services are the main
/// interface <see cref="IClashOfClans"/> and the individual interfaces <see cref="IClans"/>,
/// <see cref="ILocations"/>, <see cref="ILeagues"/>, <see cref="IPlayers"/>, <see cref="ILabels"/>
/// and <see cref="IGoldPass"/>.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection"/> to add services to.</param>
/// <param name="configureOptions">An <see cref="Action"/> to configure the provided <see cref="ClashOfClansOptionsV2"/></param>
/// <returns></returns>
public static IServiceCollection AddClashOfClans(this IServiceCollection services,
Action <ClashOfClansOptionsV2> configureOptions)
{
services.AddOptions();
services.Configure(configureOptions);
// Services
services.AddScoped(services =>
{
var options = new ClashOfClansOptionsV2();
configureOptions(options);
TokenValidator.Validate(options.Tokens);
return(new ClashOfClansOptionsInternal(options.Tokens)
{
MaxRequestsPerSecond = options.MaxRequestsPerSecond
});
});
services.AddScoped <IGameData, GameData>();
// Fine grained public interfaces
services.AddScoped <IClans, Clans>();
services.AddScoped <ILocations, Locations>();
services.AddScoped <ILeagues, Leagues>();
services.AddScoped <IPlayers, Players>();
services.AddScoped <ILabels, Labels>();
services.AddScoped <IGoldPass, GoldPass>();
// "the" API that depends on fine grained interfaces
services.AddScoped <IClashOfClans, ClashOfClansDIClient>();
return(services);
}
public JwtSecurityToken ValidateToken(string token)
{
using (TokenValidator validator = new TokenValidator(token, _currentProvider.Config.Config))
{
return(validator.Validate(_currentProvider.Config.Nonce));
}
}
public JsonResult SaveRetake(RetakeModel retake)
{
if (string.IsNullOrEmpty(retake.Term))
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Sorry, Session cannot be empty",
}));
}
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.SaveRetake(retake, classStatus).Result;
var response = JsonConvert.DeserializeObject <ReturnData <string> >(result);
return(Json(response));
}
public JsonResult GetAttendance(string usercode, string searchText, Role role)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var attendance = GetAttendanceDetails(usercode, searchText, role);
return(Json(attendance));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Sorry, An error occurred"
}));
}
}
public JsonResult GetEmpPnine(string userCode, int year)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Staff)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to access this page",
}));
}
var statementResult = _unisolApiProxy.GetEmpPnine(userCode, year).Result;
var jdata = new ProcessJsonReturnResults <dynamic>(statementResult).UnisolApiData;
return(Json(jdata));
}
public JsonResult GetLeaveApplications(string status)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Staff)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to view this page",
}));
}
var applications = _unisolApiProxy.GetLeaveApplications(status).Result;
var jdata = JsonConvert.DeserializeObject <ReturnData <List <HrpLeaveApp> > >(applications);
return(Json(jdata));
}
public JsonResult GetPerformanceTemplate()
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var performance = _context.StaffPerformance.ToList();
return(Json(new ReturnData <List <StaffPerformance> > {
Success = true,
Data = performance
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string> {
Success = false,
Message = "Sorry, An error occurred"
}));
}
}
public void ValidateTest()
{
SuncereDataCenterModel entities = new SuncereDataCenterModel();
TokenValidator validator = new TokenValidator(entities);
TokenModel tm = new TokenModel("admin", "123456");
string token = AsymmetricEncryption.Default.EncryptToString(JsonConvert.SerializeObject(tm));
bool result = validator.Validate(token, "AirQuality", null);
Assert.IsFalse(result);
tm = new TokenModel("admin", "Suncere@123");
token = AsymmetricEncryption.Default.EncryptToString(JsonConvert.SerializeObject(tm));
result = validator.Validate(token, "AirQuality", null);
Assert.IsTrue(result);
result = validator.Validate(token, "AirQuality", "");
Assert.IsFalse(result);
result = validator.Validate("123456", "", "");
Assert.IsFalse(result);
}
public JsonResult GetProgram(string regNo, string year)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetStudentProgram(regNo, year, classStatus).Result;
var response = new ProcessJsonReturnResults <List <ProgramType> >(result).UnisolApiData;
return(Json(response));
}
public JsonResult GetStudentData(string userCode)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetStudentData(userCode, classStatus).Result;
var response = new ProcessJsonReturnResults <dynamic>(result).UnisolApiData;
return(Json(response));
}
public void OnAuthorization(AuthorizationFilterContext context)
{
var v = context.HttpContext.Request.Headers["Authorization"].FirstOrDefault();
if (v != null)
{
var user = TokenValidator.Validate(v.Split(' ')[1]);
context.HttpContext.User = user;
}
}
public JsonResult GetStudyTimetable([FromBody] RegisterViewModel reg)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetStudyTimetable(reg, classStatus).Result;
var response = JsonConvert.DeserializeObject <ReturnData <dynamic> >(result);
return(Json(response));
}
public JsonResult GetIR(string usercode)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (token.Role != Role.Staff)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = "Sorry, you are not authorized to perform this action",
}));
}
var ir = _unisolApiProxy.GetIR(usercode).Result;
var jdata = JsonConvert.DeserializeObject <ReturnData <dynamic> >(ir);
if (!jdata.Success)
{
return(Json(new ReturnData <ProcOnlineReq>
{
Success = false,
Message = jdata.Message
}));
}
return(Json(new ReturnData <dynamic>
{
Success = true,
Message = jdata.Message,
Data = jdata.Data
}));
}
public JsonResult GetStudentProvisionalTranscript(TranscriptRequestViewModel transcriptRequestViewModel)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetStudentProvisionalTranscript(transcriptRequestViewModel, classStatus).Result;
var response = new ProcessJsonReturnResults <dynamic>(result).UnisolApiData;
return(Json(response));
}
public string Post([FromBody] string value)
{
var claim = _tokenValidator.Validate(value);
if (claim != null)
{
return(claim.Identities.FirstOrDefault().Name);
}
throw new Exception("Unautherised.");
}
public JsonResult GetImprestMemo(string usercode, string searchText)
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetImprestMemo(usercode, searchText).Result;
var response = JsonConvert.DeserializeObject <ReturnData <dynamic> >(result);
return(Json(response));
}
public JsonResult GetWorkOrders(string usercode)
{
usercode = usercode ?? "";
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var result = _unisolApiProxy.GetWorkOrders(usercode.Trim()).Result;
var response = JsonConvert.DeserializeObject <ReturnData <List <ESWorkRequest> > >(result);
return(Json(response));
}
public async Task <JsonResult> Apply(StudClearance clearance, Role role)
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
if (string.IsNullOrEmpty(clearance.Notes))
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Kindly, provide clearance reason"
}));
}
clearance.Personnel = clearance.AdmnNo;
clearance.Rdate = DateTime.UtcNow.Date;
clearance.Status = "Pending";
var app = await _unisolApiProxy.ApplyClearance(clearance, role);
var jdata = JsonConvert.DeserializeObject <ReturnData <string> >(app);
return(Json(jdata));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "Sorry, An error occurred",
}));
}
}
public JsonResult GetHostels()
{
try
{
var token = _tokenValidator.Validate(HttpContext);
if (!token.Success)
{
return(Json(new ReturnData <string>
{
Success = false,
NotAuthenticated = true,
Message = $"Unauthorized:-{token.Message}",
}));
}
var hostels = _unisolApiProxy.GetHostels().Result;
var jdata = JsonConvert.DeserializeObject <ReturnData <List <Hostels> > >(hostels);
if (jdata.Success)
{
return(Json(new ReturnData <List <Hostels> >
{
Success = true,
Message = jdata.Message,
Data = jdata.Data
}));
}
return(Json(new ReturnData <ProcOnlineReq>
{
Success = false,
Message = "There was a problem while retrieving Hostels, please try again"
}));
}
catch (Exception ex)
{
return(Json(new ReturnData <string>
{
Success = false,
Message = "An error occured while trying to get Hostels, please try again " + ex.Message
}));
}
}
