/// <summary>
/// Create Object with <see cref="ParamsAccessToken"/>
/// </summary>
/// <param name="paramAccessToken">param access token object</param>
public static Task <ClickUpApi> CreateAsync(ParamsAccessToken paramAccessToken)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest("oauth/token", Method.POST);
request.AddParameter("client_id", paramAccessToken.ClientId);
request.AddParameter("client_secret", paramAccessToken.ClientSecret);
request.AddParameter("code", paramAccessToken.Code);
// execute the request
var taskCompletionSource = new TaskCompletionSource <ClickUpApi>();
var task = RestSharperHelper.ExecuteRequestAsync <ResponseAccessToken, ResponseError>(client, request)
.ContinueWith(responseTask => {
ResponseGeneric <ResponseAccessToken, ResponseError> response = responseTask.Result;
// Manage Response
if (response.ResponseSuccess == null)
{
throw new Exception(response.ResponseError.Err);
}
string accessToken = response.ResponseSuccess.AccessToken;
taskCompletionSource.SetResult(new ClickUpApi(accessToken));
});
return(taskCompletionSource.Task);
}
public static ResponseGeneric ModificarProfesor(Teacher model)
{
ResponseGeneric response = new ResponseGeneric();
response.status = false;
if (ProfesorDataAccess.getPerson(model.Id) == null)
{
response = ProfesorDataAccess.ModificarProfesor(model);
if (response.status)
{
response.error = "Profesor modificado satisfactoriamente";
}
else
{
response.error = "Error al modificar el profesor";
}
}
else
{
response.error = "La persona ya existe en la base de datos";
}
return(response);
}
protected ResponseGeneric <T> CriarResposta <T>(int statusCode, bool sucesso, string mensagem, IEnumerable <T> listaDto = null)
{
var response = new ResponseGeneric <T>(statusCode, sucesso, mensagem);
if (listaDto != null)
{
response.AdicionarListaDto(listaDto);
}
return(response);
}
/// <summary>
/// Get the authorized teams for this token
/// </summary>
/// <returns>ResponseGeneric with ResponseAuthorizedTeams response object</returns>
public ResponseGeneric <ResponseAuthorizedTeams, ResponseError> GetAuthorizedTeams()
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseAuthorizedTeams, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseAuthorizedTeams, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get a space's lists AKA folderless lists
/// </summary>
/// <param name="paramsGetFolderlessLists">param object of get folderless lists request</param>
/// <returns>ResponseGeneric with ResponseFolderlessLists response object</returns>
public ResponseGeneric <ResponseFolderlessLists, ResponseError> GetFolderlessLists(ParamsGetFolderlessLists paramsGetFolderlessLists)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"space/{paramsGetFolderlessLists.SpaceId}/list", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseFolderlessLists, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseFolderlessLists, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get a task by id
/// </summary>
/// <param name="paramsGetTaskById">param object of get task by id request</param>
/// <returns>ResponseGeneric with ResponseModelTask response object</returns>
public ResponseGeneric <ResponseModelTask, ResponseError> GetTaskById(ParamsGetTaskById paramsGetTaskById)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"task/{paramsGetTaskById.TaskId}", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseModelTask, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelTask, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get a team's webhooks. This team must be one of the authorized teams for this token.
/// </summary>
/// <param name="paramsGetTeamWebhook">param object of get team Webhook request</param>
/// <returns>ResponseGeneric with ResponseTeamWebhook response object</returns>
public ResponseGeneric <ResponseWebhooks, ResponseError> GetTeamWebhooks(ParamsGetTeamWebhooks paramsGetTeamWebhook)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsGetTeamWebhook.TeamId}/webhook", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseWebhooks, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseWebhooks, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Edit Task informations.
/// </summary>
/// <param name="paramsEditTask">param object of Edit Task request</param>
/// <param name="requestData">RequestEditTask object</param>
/// <returns>ResponseGeneric with ResponseSuccess response object</returns>
public ResponseGeneric <ResponseModelTask, ResponseError> EditTask(ParamsEditTask paramsEditTask, RequestEditTask requestData)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"task/{paramsEditTask.TaskId}", Method.PUT);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelTask, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelTask, ResponseError>(client, request);
return(result);
}
public static object Generate(ResponseGeneric response, SigningConfigurations signingConfigurations, TokenConfigurations tokenConfigurations)
{
User user = new User("", "", "");
if (response.Success == true)
{
if (response.Data.GetType() == typeof(User))
{
user = ((User)response.Data).GetUserWithoutPassword();
}
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(user.Id.ToString(), "Id"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(ClaimTypes.Email, user.Email.ToString()),
new Claim(ClaimTypes.Name, user.Name.ToString()),
new Claim(ClaimTypes.PrimarySid, user.Id.ToString()),
}
);
DateTime createDate = DateTime.Now;
DateTime expirationDate = createDate + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = createDate,
Expires = expirationDate
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = createDate.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = expirationDate.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK",
user = user
});
}
else
{
return(response);
}
}
public static ResponseGeneric EliminarHorario(int horarioId, int materiaId)
{
ResponseGeneric response = new ResponseGeneric();
if (MateriaDataAccess.EliminarHorario(horarioId, materiaId))
{
response.error = "Horario eliminado con exito";
}
else
{
response.error = "Hubo un problema al eliminar el horario";
}
return(response);
}
public static ResponseGeneric EliminarMateria(int Id)
{
ResponseGeneric response = new ResponseGeneric();
if (MateriaDataAccess.EliminarMateria(Id))
{
response.error = "Materia eliminada con exito";
}
else
{
response.error = "Error al eliminar la materia";
}
return(response);
}
public static ResponseGeneric EliminarProfesor(int Id)
{
ResponseGeneric response = ProfesorDataAccess.EliminarProfesor(Id);
if (response.status)
{
response.error = "Profesor eliminado con exito";
}
else
{
response.error = "Hubo un error al eliminar el profesor";
}
return(response);
}
public static ResponseGeneric EditarMateria(EditarMateriaImportModel model)
{
ResponseGeneric response = new ResponseGeneric();
if (MateriaDataAccess.EditarMateria(model))
{
response.error = "Materia modificada exitosamente";
}
else
{
response.error = "Error al modificar la materia";
}
return(response);
}
public static ResponseGeneric Inscribirse(int Id)
{
ResponseGeneric response = new ResponseGeneric();
response.status = false;
Alumn alumno = MateriaDataAccess.getAlumno(((Alumn)HttpContext.Current.Session["Usuario"]).Id);
Subject materia = MateriaDataAccess.getMateria(Id);
if (alumno.Subjects != null)
{
if (!MateriaDataAccess.AlumnoInscrito(((Alumn)HttpContext.Current.Session["Usuario"]).Id, Id))
{
foreach (var item in alumno.Subjects)
{
foreach (var subitem in item.Schedules)
{
foreach (var subsubitem in materia.Schedules)
{
if (subitem.Id == subsubitem.Id)
{
response.status = true;
response.error = "Horarios superpuestos";
}
}
}
}
}
else
{
response.status = true;
response.error = "Ya estas inscrito en esta materia";
}
}
if (!response.status)
{
if (materia.places > 0)
{
MateriaDataAccess.Inscribirse(alumno.Id, materia.Id);
response.error = "Realizado";
}
else
{
response.error = "No quedan cupos disponibles";
}
}
return(response);
}
/// <summary>
/// Create Task in List.
/// </summary>
/// <param name="paramCreateTaskInList">params object of create task in list request</param>
/// <param name="requestData">RequestCreateTaskInList object</param>
/// <returns>ResponseGeneric with ModelTask object Expected</returns>
public ResponseGeneric <ResponseModelTask, ResponseError> CreateTaskInList(ParamsCreateTaskInList paramsCreateTaskInList, RequestCreateTaskInList requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var createListRequest = new RestRequest($"list/{paramsCreateTaskInList.ListId}/task", Method.POST);
createListRequest.AddHeader("authorization", AccessToken);
createListRequest.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelTask, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelTask, ResponseError>(client, createListRequest);
return(result);
}
/// <summary>
/// Create folderless List
/// </summary>
/// <param name="paramsCreateList">param object of create list request</param>
/// <param name="requestData">RequestCreateList object</param>
/// <returns>ResponseGeneric with ModelList response object</returns>
public ResponseGeneric <ResponseModelList, ResponseError> CreateFolderlessList(ParamsCreateFolderlessList paramsCreateList, RequestCreateList requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"space/{paramsCreateList.SpaceId}/list", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelList, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelList, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Create a webhook in a Team
/// </summary>
/// <param name="paramsCreateTeamWebhook">param object of create webhook request</param>
/// <param name="requestData">RequestCreateTeamWebhook object</param>
/// <returns>ResponseGeneric with ResponseWebhook response object</returns>
public ResponseGeneric <ResponseWebhook, ResponseError> CreateTeamWebhook(ParamsCreateTeamWebhook paramsCreateTeamWebhook, RequestCreateTeamWebhook requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsCreateTeamWebhook.TeamId}/webhook", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseWebhook, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseWebhook, ResponseError>(client, request);
return(result);
}
public static ResponseGeneric ModificarProfesor(Teacher model)
{
ResponseGeneric response = new ResponseGeneric();
using (MyDbContext db = new MyDbContext())
{
Teacher teacher = db.Teacher.FirstOrDefault(x => x.Id == model.Id);
teacher.Ci = model.Ci;
teacher.name = model.name;
teacher.last_name = model.last_name;
db.Entry(teacher).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
response.status = true;
}
return(response);
}
public static ResponseGeneric EliminarProfesor(int Id)
{
ResponseGeneric response = new ResponseGeneric();
response.status = false;
try
{
using (MyDbContext db = new MyDbContext())
{
db.Teacher.Remove(db.Teacher.FirstOrDefault(x => x.Id == Id));
db.SaveChanges();
response.status = true;
}
}
catch (Exception ex)
{
}
return(response);
}
public static ResponseGeneric CrearProfesor(CrearProfesorImportModel model)
{
ResponseGeneric response = new ResponseGeneric();
response.status = false;
using (MyDbContext db = new MyDbContext())
{
Teacher teacher = new Teacher()
{
Ci = model.ci,
name = model.name,
last_name = model.last_name,
active = "no"
};
db.Teacher.Add(teacher);
db.SaveChanges();
response.status = true;
}
return(response);
}
public static ResponseGeneric CrearProfesor(CrearProfesorImportModel model)
{
ResponseGeneric response = new ResponseGeneric();
if (ProfesorDataAccess.getPerson(model.ci) == null)
{
response = ProfesorDataAccess.CrearProfesor(model);
if (response.status)
{
response.error = "Profesor creado con exito";
}
else
{
response.error = "Hubo un error al crear el profesor";
}
}
else
{
response.error = "La persona ya existe en la base de datos";
}
return(response);
}
public static ResponseGeneric AgregarMateria(AgregarMateriaImportModel model)
{
ResponseGeneric response = new ResponseGeneric();
response.status = false;
if (!MateriaDataAccess.ExistenciaMateria(model.name))
{
if (MateriaDataAccess.AgregarMateria(model))
{
response.error = "Materia agregada con exito";
}
else
{
response.error = "Error al agregar la materia";
}
}
else
{
response.error = "Ya existe esta materia";
}
return(response);
}
/// <summary>
/// Create Object with <see cref="ParamsAccessToken"/>
/// </summary>
/// <param name="paramAccessToken">param access token object</param>
public static ClickUpApi Create(ParamsAccessToken paramAccessToken)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest("oauth/token", Method.POST);
request.AddParameter("client_id", paramAccessToken.ClientId);
request.AddParameter("client_secret", paramAccessToken.ClientSecret);
request.AddParameter("code", paramAccessToken.Code);
// execute the request
ResponseGeneric <ResponseAccessToken, ResponseError> response = RestSharperHelper.ExecuteRequest <ResponseAccessToken, ResponseError>(client, request);
string accessToken;
// Manage Response
if (response.ResponseSuccess == null)
{
throw new Exception(response.ResponseError.Err);
}
accessToken = response.ResponseSuccess.AccessToken;
return(new ClickUpApi(accessToken));
}
