public async Task <GenericResponse> RegisterStudent(HelpsRegisterRequest request)
{
var response = helpsClient.PostAsJsonAsync("api/student/register", request).Result;
if (response.IsSuccessStatusCode)
{
HelpsResponse decodedResponse = response.Content.ReadAsAsync <HelpsResponse>().Result;
if (decodedResponse.IsSuccess)
{
var user = userTable.CurrentUser();
user.HasLoggedIn = true;
AuthService auth = new AuthService();
GenericResponse Response = await auth.CompleteSetup(userTable.CurrentUser().StudentId);
if (Response.Success)
{
userTable.SetUser(user);
return(ResponseHelper.Success());
}
}
else
{
return(ResponseHelper.CreateErrorResponse("Registration Failed", decodedResponse.DisplayMessage));
}
}
return(ResponseHelper.CreateErrorResponse("Registration Failed", "An unknown error occurred"));
}
public async Task <GenericResponse> AddNotes(string notes, int workshopId)
{
if (!IsConnected())
{
return(ResponseHelper.CreateErrorResponse("No Network Connection", "Please check your network connection and try again"));
}
var request = new WorkshopBookingUpdate()
{
workshopId = workshopId,
studentId = AuthService.GetCurrentUser().StudentId,
userId = AuthService.GetCurrentUser().StudentId,
notes = notes
};
var response = await helpsClient.PutAsJsonAsync("api/sessionId/booking/update", request);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <GetResponse <GenericResponse> >();
if (result.IsSuccess)
{
workshopBookingTable.UpdateNotes(notes, workshopId);
return(ResponseHelper.Success());
}
return(ResponseHelper.CreateErrorResponse("Error", result.DisplayMessage));
}
return(ResponseHelper.CreateErrorResponse("Error", "An unknown error occurred, please try again"));
}
public async Task <ApiResponse> Update(UserDTO input)
{
var entity = await _repository.GetAsync(input.Id);
if (entity == null)
{
return(ResponseHelper.CreateErrorResponse(string.Format(Constants.NotFound, input.UserName)));
}
entity.FirstName = input.FirstName;
entity.LastName = input.LastName;
entity.UserName = input.UserName;
entity.Password = input.Password;
entity.PhoneNumber = input.PhoneNumber;
entity.RoleId = input.RoleId;
try
{
entity = await _manager.CreateAsync(entity);
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse(ex.Message));
}
await _repository.UpdateAsync(entity);
await _work.Complete();
return(ResponseHelper.CreateUpdateSuccessResponse());
}
public async Task <Response <Booking> > GetBookings(string studentId, bool?current = null)
{
var queryString = "studentId=" + studentId + "&active=true";
if (current.HasValue)
{
if (current.Value)
{
queryString += "&startingDtBegin=" + DateTime.Now.ToString(DateFormat) + "&startingDtEnd=" +
DateTime.MaxValue.AddMonths(-1).ToString(DateFormat);
}
else
{
queryString += "&startingDtBegin=" + DateTime.MinValue.AddYears(2000).ToString(DateFormat) +
"&startingDtEnd=" + DateTime.Now.ToString(DateFormat);
}
}
var response = await helpsClient.GetAsync("api/workshop/booking/search?" + queryString);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <Response <Booking> >();
return(result);
}
return(ResponseHelper.CreateErrorResponse <Booking>("An unknown error occured"));
}
public async Task <ApiResponse> Update(TaskDTO task)
{
var entity = await _repository.GetAsync(task.Id);
if (entity == null)
{
return(ResponseHelper.CreateErrorResponse(string.Format(Constants.NotFound, task.TaskName)));
}
var type = new TaskInfo();
entity.TaskName = task.TaskName;
entity.Time = task.Time;
try
{
entity = await _manager.CreateAsync(entity);
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse(ex.Message));
}
await _repository.UpdateAsync(entity);
await _work.Complete();
return(ResponseHelper.CreateUpdateSuccessResponse());
}
public async Task <ApiResponse> GetById(int id)
{
var smartFolder = await _repository.FindAsync(r => r.Id == id, true, default(CancellationToken));
if (smartFolder == null)
{
return(ResponseHelper.CreateErrorResponse(string.Format(Constants.NotFound, "Smart Folder")));
}
var UserViewModel = _mapper.Map <UserViewModel>(smartFolder);
return(ResponseHelper.CreateGetSuccessResponse(UserViewModel));
}
public async Task <GenericResponse> Login(LoginRequest request)
{
try
{
var response = await authClient.InvokeApiAsync <LoginRequest, User>("SignIn", request);
userTable.SetUser(response);
return(ResponseHelper.Success());
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse("Login Failure", ex));
}
}
public async Task <Response <Workshop> > GetWorkshop(int workshopId)
{
TestConnection();
var response = await helpsClient.GetAsync("api/workshop/" + workshopId.ToString());
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <Response <Workshop> >();
return(result);
}
return(ResponseHelper.CreateErrorResponse <Workshop>("An unknown error occured"));
}
public async Task <Response <Workshop> > GetWorkshops(int workshopSetId)
{
TestConnection();
var queryString = "workshopSetId=" + workshopSetId + "&active=true" + "&startingDtBegin=" + DateTime.Now.ToString(DateFormat);
var response = await helpsClient.GetAsync("api/workshop/search?" + queryString);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <Response <Workshop> >();
return(result);
}
return(ResponseHelper.CreateErrorResponse <Workshop>("Could not find workshops"));
}
public async Task <Response <WorkshopSet> > GetWorkshopSets()
{
TestConnection();
var response = await helpsClient.GetAsync("api/workshop/workshopSets/true");
if (response.IsSuccessStatusCode)
{
var results = await response.Content.ReadAsAsync <Response <WorkshopSet> >();
return(results);
}
return(ResponseHelper.CreateErrorResponse <WorkshopSet>("Could not find workshop sets"));
}
public async Task <GenericResponse> ForgotPassword(string StudentId)
{
try
{
Dictionary <string, string> paramaters = new Dictionary <string, string>();
paramaters.Add("studentId", StudentId);
JToken response = await authClient.InvokeApiAsync("ForgotPassword", HttpMethod.Get, paramaters);
return(ResponseHelper.Success());
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse("Failure", ex));
}
}
public async Task <GenericResponse> Register(RegisterRequest request)
{
try
{
userTable.SetUser(new User {
FirstName = request.FirstName, LastName = request.LastName, Email = request.Email, StudentId = request.StudentId
});
var response = await authClient.InvokeApiAsync <RegisterRequest, GenericResponse>("Registration", request);
return(ResponseHelper.Success());
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse("Registration Failure", ex));
}
}
public async Task <GenericResponse> ResendConfirmation(string StudentId)
{
try
{
Dictionary <string, string> paramaters = new Dictionary <string, string>();
paramaters.Add("StudentId", StudentId);
paramaters.Add("Resend", "true");
JToken response = await authClient.InvokeApiAsync("ConfirmEmail", HttpMethod.Get, paramaters);
return(ResponseHelper.Success());
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse("Failure", ex));
}
}
public async Task <ApiResponse> Add(TaskDTO input)
{
var entity = _mapper.Map <TaskInfo>(input);
try
{
entity = await _manager.CreateAsync(entity);
}
catch (Exception ex)
{
return(ResponseHelper.CreateErrorResponse(ex.Message));
}
await _repository.InsertAsync(entity);
await _work.Complete();
return(ResponseHelper.CreateAddSuccessResponse());
}
public async Task <GenericResponse> JoinWaitlist(int id)
{
if (!IsConnected())
{
return(ResponseHelper.CreateErrorResponse("No Network Connection", "Please check your network connection and try again"));
}
var response = await helpsClient.PostAsync("api/workshop/wait/create?" + "workshopId=" + id + "&studentId=" + AuthService.GetCurrentUser().StudentId + "&userId=" + AuthService.GetCurrentUser().StudentId, null);
if (!response.IsSuccessStatusCode)
{
return(ResponseHelper.CreateErrorResponse("Error", "An unknown error occured"));
}
var result = await response.Content.ReadAsAsync <GetResponse <GenericResponse> >();
return((result.IsSuccess) ?
ResponseHelper.Success() :
ResponseHelper.CreateErrorResponse("Error", result.DisplayMessage));
}
public async Task <Response <Campus> > GetCampus(int campusId)
{
TestConnection();
var response = await helpsClient.GetAsync("api/misc/campus/true");
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <Response <Campus> >();
if (result.IsSuccess)
{
var campus = result.Results.Where(c => c.id == campusId).FirstOrDefault();
return(ResponseHelper.CreateResponseDetail(campus));
}
return(ResponseHelper.CreateErrorResponse <Campus>("Could not find campus records"));
}
return(ResponseHelper.CreateErrorResponse <Campus>("An unkown error occured"));
}
private async Task <GenericResponse> BookingBase(CancellationToken ct, string endpoint, string queryString)
{
if (!IsConnected())
{
return(ResponseHelper.CreateErrorResponse("No Network Connection", "Please check your network connection and try again"));
}
var response = await helpsClient.PostAsync(endpoint + queryString + "&studentId=" + AuthService.GetCurrentUser().StudentId + "&userId=" + AuthService.GetCurrentUser().StudentId, null);
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <GetResponse <GenericResponse> >();
if (result.IsSuccess)
{
await GetBookings(ct, true, false, true);
return(ResponseHelper.Success());
}
return(ResponseHelper.CreateErrorResponse("Error", result.DisplayMessage));
}
return(ResponseHelper.CreateErrorResponse("Error", "An unknown error occured"));
}