public async Task <bool> isMailExisting(string email, IStObjMap stObjMap)
{
try
{
SqlDefaultDatabase db = stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (var ctx = new SqlStandardCallContext())
{
UserQueries groupQueries = new UserQueries(ctx, db);
int exists = await groupQueries.CheckEmail(email);
if (exists != 0)
{
return(true);
}
else
{
return(false);
}
}
}
catch
{
return(false);
}
}
public async Task <IActionResult> GetAllGradeProject()
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
GroupData groupData = await groupQueries.GetIdSchoolByConnectUser(userId);
AclQueries aclQueries = new AclQueries(ctx, db);
if (await aclQueries.VerifyGrantLevelByUserId(112, await aclQueries.GetAclIdBySchoolId(groupData.ParentZoneId), userId, Operator.SuperiorOrEqual) == false)
{
Result result = new Result(Status.Unauthorized, "Vous n'etes pas autorisé à utiliser cette fonctionnalité !");
return(this.CreateResult(result));
}
List <ProjectInfosJuryData> projects = await projectQueries.getAllProjectsGrade(groupData.ZoneId);
List <ProjectForumResultData> listToSend = GetProjectsOfForum(projects);
return(Ok(listToSend));
}
}
public async Task <IActionResult> GetInfosProject(int idProject)
{
ProjectStudentTable projectTable = _stObjMap.StObjs.Obtain <ProjectStudentTable>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
ProjectDetailsData projectDetails = new ProjectDetailsData
{
Project = await projectQueries.GetDetailProject(idProject),
Students = await projectQueries.GetAllUsersOfProject(idProject)
};
List <string> listGroups = await projectQueries.GetGroupsOfProject(idProject);
listGroups = listGroups.FindAll(x => x.StartsWith("S0") || x == "IL" || x == "SR");
string groups = listGroups[0];
if (listGroups.Count >= 2)
{
for (int i = 1; i < listGroups.Count; i++)
{
groups += "-" + listGroups[i];
}
}
projectDetails.Project.Semester = groups;
return(Ok(projectDetails));
}
}
public static async Task SaveProject(
Type projectType,
Project toml,
int userId,
SqlDefaultDatabase db,
ProjectStudentTable projectTable,
CustomGroupTable groupTable,
ProjectUrlTable projectUrl
)
{
using (SqlStandardCallContext ctx = new SqlStandardCallContext())
{
// letter of project type
string type;
if (projectType.Name == "ProjectPi")
{
type = "I";
}
else if (projectType.Name == "ProjectPfh")
{
type = "H";
}
else
{
type = "¤";
}
if (type == "I")
{
ProjectPi project = toml as ProjectPi;
// register the project
(UserQueries userQueries, TimedUserQueries timedUserQueries, ProjectStudentStruct ProjectCreate, TimedUserData timedUser) = await SaveProjectPi(project, projectTable, userId, db, ctx, type, projectUrl, groupTable);
// link members to the project
if (toml.team.members.Length > 0)
{
await LinkMembersToProject(project, userQueries, timedUserQueries, ProjectCreate, timedUser, groupTable, ctx);
}
}
else if (type == "H")
{
ProjectPfh project = toml as ProjectPfh;
// register the project
(UserQueries userQueries, TimedUserQueries timedUserQueries, ProjectStudentStruct ProjectCreate, TimedUserData timedUser) = await SaveProjectPfh(project, projectTable, userId, db, ctx, type, projectUrl, groupTable);
// link members to the project
if (toml.team.members.Length > 0)
{
await LinkMembersToProject(project, userQueries, timedUserQueries, ProjectCreate, timedUser, groupTable, ctx);
}
}
}
}
public async Task <IActionResult> FavProject(int idProject)
{
int userId = _authenticationInfo.ActualUser.UserId;
UserFavProjectTable favTable = _stObjMap.StObjs.Obtain <UserFavProjectTable>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (var ctx = new SqlStandardCallContext())
{
await favTable.FavOrUnfavProject(ctx, userId, idProject);
return(Ok( ));
}
}
public async Task <IActionResult> GetAllTypeProjectsOfASchool(int idSchool, char type)
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
PeriodData periodData = await timedPeriodQueries.GetLastPeriodBySchool(idSchool);
//Implementer check date period
TimedUserData timedUserData = await timedUserQueries.GetTimedUser(userId, periodData.ChildId);
if (timedUserData == null)
{
timedUserData = new TimedUserData
{
TimedUserId = 0
};
}
IEnumerable <AllProjectInfoData> projectData = await projectQueries.GetAllTypeProjectSpecificToSchoolWithTimedUserNote(periodData.ChildId, type, timedUserData.TimedUserId);
for (var i = 0; i < projectData.Count(); i++)
{
IEnumerable <UserByProjectData> userByProject = await userQueries.GetUserByProject(projectData.ElementAt( i ).ProjectStudentId);
projectData.ElementAt(i).BegDate = userByProject.ElementAt(0).BegDate;
projectData.ElementAt(i).EndDate = userByProject.ElementAt(0).EndDate;
foreach (var e in userByProject)
{
IEnumerable <GroupData> groupDatas = await groupQueries.GetAllGroupByTimedUser(e.TimedUserId);
projectData.ElementAt(i).FirstName.Add(e.FirstName);
projectData.ElementAt(i).LastName.Add(e.LastName);
projectData.ElementAt(i).TimedUserId.Add(e.TimedUserId);
projectData.ElementAt(i).UserId.Add(e.UserId);
}
}
return(Ok(projectData));
}
}
public async Task <IActionResult> SubmitProject([FromBody] SubmitProjectModel project)
{
ProjectStudentTable projectTable = _stObjMap.StObjs.Obtain <ProjectStudentTable>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
CustomGroupTable groupTable = _stObjMap.StObjs.Obtain <CustomGroupTable>();
ProjectUrlTable projectUrl = _stObjMap.StObjs.Obtain <ProjectUrlTable>();
return(Ok(await TomlHelpers.TomlHelpers.RegisterProject(
project.Link,
project.ProjectType,
projectTable,
project.UserId,
db,
groupTable,
_stObjMap,
projectUrl
)));
}
public async Task <IActionResult> BlockedProject([FromBody] BlockedGradeViewModel model)
{
int userId = _authenticationInfo.ActualUser.UserId;
EvaluatesTable evaluatesTable = _stObjMap.StObjs.Obtain <EvaluatesTable>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
PeriodServices periodServices = new PeriodServices();
using (var ctx = new SqlStandardCallContext())
{
AclQueries aclQueries = new AclQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
if (!await periodServices.CheckInPeriod(_stObjMap, _authenticationInfo))
{
Result result = new Result(Status.Unauthorized, "A la date d'aujourd'hui votre etablissement n'est dans une aucune periode");
return(this.CreateResult(result));
}
GroupData groupData = await groupQueries.GetIdSchoolByConnectUser(userId);
if (!await aclQueries.VerifyGrantLevelByUserId(112, await aclQueries.GetAclIdBySchoolId(groupData.ParentZoneId), userId, Operator.SuperiorOrEqual))
{
Result result = new Result(Status.Unauthorized, "Vous n'etes pas autorisé à utiliser cette fonctionnalité !");
return(this.CreateResult(result));
}
int idx = 0;
foreach (var item in model.IndividualGrade)
{
if (item.Value > 0)
{
await evaluatesTable.BlockedProjectGrade(ctx, model.JurysId[idx], model.ProjectId, item.Value, true);
}
else
{
await evaluatesTable.BlockedProjectGrade(ctx, model.JurysId[idx], model.ProjectId, true);
}
idx++;
}
return(Ok());
}
}
public async Task <IEnumerable <AllProjectInfoData> > GetAllProjects()
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
IEnumerable <AllProjectInfoData> projectData = await projectQueries.GetAllProject(userId);
for (var i = 0; i < projectData.Count(); i++)
{
IEnumerable <UserByProjectData> userByProject = await userQueries.GetUserByProject(projectData.ElementAt( i ).ProjectStudentId);
projectData.ElementAt(i).BegDate = userByProject.ElementAt(0).BegDate;
projectData.ElementAt(i).EndDate = userByProject.ElementAt(0).EndDate;
List <string> listGroups = await projectQueries.GetGroupsOfProject(projectData.ElementAt(i).ProjectStudentId);
List <string> semester = listGroups.FindAll(x => x.StartsWith("S0"));
projectData.ElementAt(i).Semester = semester[0];
List <string> sector = listGroups.FindAll(x => x.StartsWith("IL") || x.StartsWith("SR"));
if (sector.Count() > 0)
{
projectData.ElementAt(i).Sector = sector[0];
}
GroupData data = await groupQueries.GetIdSchoolByPeriodId(projectData.ElementAt( i ).ZoneId);
projectData.ElementAt(i).SchoolId = data.ParentZoneId;
foreach (var e in userByProject)
{
//IEnumerable<GroupData> groupDatas = await groupQueries.GetAllGroupByTimedUser( e.TimedUserId );
projectData.ElementAt(i).FirstName.Add(e.FirstName);
projectData.ElementAt(i).LastName.Add(e.LastName);
projectData.ElementAt(i).TimedUserId.Add(e.TimedUserId);
projectData.ElementAt(i).UserId.Add(e.UserId);
}
}
return(projectData);
}
}
public async Task <UserLoginResult> CreateAccountAndLoginAsync(IActivityMonitor monitor, IWebFrontAuthAutoCreateAccountContext context)
{
var userTable = _stObjMap.StObjs.Obtain <CustomUserTable>();
var actorEmail = _stObjMap.StObjs.Obtain <ActorEMailTable>();
var oidcTable = _stObjMap.StObjs.Obtain <UserOidcTable>();
ICustomUserOidcInfos infos = (ICustomUserOidcInfos)context.Payload;
ISqlCallContext ctx = context.HttpContext.RequestServices.GetService <ISqlCallContext>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (var sqlCtx = new SqlStandardCallContext())
{
UserQueries userQueries = new UserQueries(sqlCtx, db);
int exists = await userQueries.CheckEmail(infos.Email);
if (exists == 0)
{
int userId = await userTable.CreateUserAsync(ctx, 1, Guid.NewGuid().ToString(),
infos.FirstName, infos.LastName);
await actorEmail.AddEMailAsync(ctx, 1, userId, infos.Email, true, false);
UCLResult result = await oidcTable.CreateOrUpdateOidcUserAsync(
ctx, 1, userId, infos, UCLMode.CreateOrUpdate | UCLMode.WithActualLogin);
if (result.OperationResult != UCResult.Created)
{
return(null);
}
return(await _dbAuth.CreateUserLoginResultFromDatabase(ctx, _typeSystem, result.LoginResult));
}
else
{
UCLResult result = await oidcTable.CreateOrUpdateOidcUserAsync(
ctx, 1, exists, infos, UCLMode.CreateOrUpdate | UCLMode.WithActualLogin);
return(await _dbAuth.CreateUserLoginResultFromDatabase(ctx, _typeSystem, result.LoginResult));
}
}
}
public async Task <IActionResult> GetAllPublicNote()
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
GroupData groupData = await groupQueries.GetIdSchoolByConnectUser(userId);
List <ProjectForumResultData> projects = await projectQueries.GetAllPublicsNoteByTimedPeriodId(groupData.ZoneId);
return(Ok(projects));
}
}
public async Task <IEnumerable <AllProjectInfoData> > GetProjectsEvaluate(int idSchool)
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
PeriodData periodData = await timedPeriodQueries.GetLastPeriodBySchool(idSchool);
//Implementer check date period
IEnumerable <AllProjectInfoData> projectData = await projectQueries.GetAllProjectTimedByJuryId(userId, periodData.ChildId);
return(projectData);
}
}
public ProjectQueries(ISqlCallContext ctx, SqlDefaultDatabase sqlDefaultDatabase)
{
_controller = ctx.GetConnectionController(sqlDefaultDatabase);
}
// may we should rewrite the sql query
public async Task <object> GetProjectSheet(int idx)
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
ProjectData pd;
List <UserData> lst_usr_data;
List <string> lst_grp;
using (SqlStandardCallContext ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
pd = await projectQueries.GetDetailProject(idx);
lst_usr_data = await projectQueries.GetAllUsersOfProject(idx);
lst_grp = await projectQueries.GetGroupsOfProject(idx);
}
string name = pd.Name;
// semesters of the project
List <int> semesters = new List <int>();
foreach (string elem in lst_grp)
{
if (elem[0] == 'S' && (elem[1] == '0' || elem[1] == '1'))
{
semesters.Add(int.Parse(elem.Substring(1, elem.Length - 1)));
}
}
semesters.Sort();
string semester = String.Join(", ", semesters);
// sector of the project
string sector = lst_grp.Contains("SR") && lst_grp.Contains("IL") ? "IL - SR" : lst_grp.Contains("SR") ? "SR" : lst_grp.Contains("IL") ? "IL" : "";
// download and encode the image in base64
string logo = Convert.ToBase64String(new WebClient().DownloadData(pd.Logo));
string slogan = pd.Slogan;
string pitch = pd.Pitch;
// check who is the leader
string[] members = new string[lst_usr_data.Count - 1];
string leader = "";
foreach (UserData usr in lst_usr_data)
{
if (usr.UserId == pd.LeaderId)
{
leader = usr.FirstName + " " + usr.LastName;
}
else
{
members[Array.IndexOf(members, null)] = usr.FirstName + " " + usr.LastName;
}
}
(string, string[])team = (leader, members);
// check the type for the field techno of background field and return the project
if (pd.Type == "I")
{
string[] place = new string[2];
place[0] = pd.ClassRoom;
place[1] = pd.ForumNumber.ToString();
string[] technos = pd.Technologies.ToArray();
return(new { project = new ProjectPiSheet(place, name, semester, sector, logo, slogan, pitch, team, technos), type = "I" });
}
else if (pd.Type == "H")
{
// download and encode the background in base64
string background = Convert.ToBase64String(new WebClient().DownloadData(pd.Background));
return(new { project = new ProjectPfhSheet(name, semester, sector, logo, slogan, pitch, team, background), type = "H" });
}
else
{
return(new { project = new ProjectSheet(name, semester, sector, logo, slogan, pitch, team, "None"), type = "None" });
}
}
public static async Task <(bool, string)> RegisterProject(
string url,
int projectNumber,
ProjectStudentTable projectTable,
int userId,
SqlDefaultDatabase db,
CustomGroupTable groupTable,
IStObjMap stObjMap,
ProjectUrlTable projectUrlTable
)
// given url, we register the project if he can be downloaded and parsed
{
string tomlString;
Project toml;
Type projectType;
try // get the type of the project
{
projectType = new Type[] { typeof(ProjectPi), typeof(ProjectPfh) }[projectNumber];
}
catch
{
return(false, "Le numéro pour le type de projet n'est pas bon.");
}
try // to get the ressource
{
tomlString = GetOnlineToml(GetTomlFromGoogleDrive.GetUrlRessource(url));
}
catch
{
return(false, "La ressource n'est pas trouvée, peut-être que le liens n'est pas le bon.");
}
try // parse the toml
{
var method = typeof(TomlHelpers).GetMethod("GetInstanceFromToml");
method = method.MakeGenericMethod(projectType);
toml = (Project)method.Invoke(null, new object[] { tomlString });
}
catch (Exception e)
{
List <string> foo = e.ToString().Split("-->")[1].Split(":").Skip(1).Take(2).ToList();
foo[1] = foo[1].Split(".")[0];
return(false, "Impossible de parser le fichier toml, est-ce que le fichier est correctement formaté ?\n" + String.Join(": ", foo));
}
(bool isValid, string message) = toml.isValid();
if (!isValid) // check if we got fild we want
{
return(false, message); // "There is missing or bad field in the toml file");
}
toml.logo.url = GetTomlFromGoogleDrive.GetUrlRessource(toml.logo.url);
if (toml.team.leader != "None" && !await toml.team.isMailExisting(toml.team.leader, stObjMap))
{
return(false, "L'e-mail du chef de projet est invalide.");
}
foreach (string mail in toml.team.members)
{
if (!await toml.team.isMailExisting(mail, stObjMap))
{
return(false, "L'un des e-mails des membres est invalide.");
}
}
;
try // register the project in the bdd
{
await RegisterProjectInBDD.SaveProject(projectType, toml, userId, db, projectTable, groupTable, projectUrlTable);
}
catch (Exception e)
{
return(false, "Impossible de sauvegarder le projet dans la BDD.");
}
return(true, "Le projet a été sauvegarde avec succès.");
}
public static async Task <(UserQueries, TimedUserQueries, ProjectStudentStruct, TimedUserData)> SaveProjectPi(
ProjectPi project,
ProjectStudentTable projectTable,
int userId,
SqlDefaultDatabase db,
SqlStandardCallContext ctx,
string type,
ProjectUrlTable projectUrlTable,
CustomGroupTable CustomGroupTable
)
{
GroupQueries groupQueries = new GroupQueries(ctx, db);
TraitContextQueries traitContext = new TraitContextQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupData school = await groupQueries.GetIdSchoolByConnectUser(userId);
// PeriodData timePeriod = await timedPeriodQueries.GetLastPeriodBySchool(school.ZoneId);
TimedUserData timedUser = await timedUserQueries.GetTimedUser(userId, school.ZoneId);
int traitContextId = await traitContext.GetTraitContextId(type);
string email = project.team.leader;
int leaderId;
if (email == "None")
{
leaderId = 0;
}
else
{
UserData user = await userQueries.GetUserByEmail(email);
TimedUserData timedLeader = await timedUserQueries.GetTimedUser(user.UserId, school.ZoneId);
leaderId = user.UserId;
}
ProjectStudentStruct ProjectCreate = await projectTable.CreateProjectStudent(
ctx,
userId,
school.ZoneId,
project.name.project_name,
traitContextId,
string.Join(";", project.technologies.technologies),
project.logo.url,
project.slogan.slogan,
project.pitch.pitch,
leaderId,
type
);
if (project.git.url != "None")
{
await projectUrlTable.CreateOrUpdateProjectUrl(ctx, ProjectCreate.ProjectStudentId, project.git.url, "Git");
}
foreach (var item in project.semester.semester)
{
string semester = "S0" + item.ToString();
int idSemester = await groupQueries.GetSpecificIdGroupByZoneIdAndGroupName(school.ZoneId, semester);
await CustomGroupTable.AddUserAsync(ctx, userId, idSemester, ProjectCreate.ProjectStudentId, true);
}
string[] sector = project.semester.sector.Split(" - ");
foreach (var item in sector)
{
int idSector = await groupQueries.GetSpecificIdGroupByZoneIdAndGroupName(school.ZoneId, item);
await CustomGroupTable.AddUserAsync(ctx, userId, idSector, ProjectCreate.ProjectStudentId, true);
}
return(userQueries, timedUserQueries, ProjectCreate, timedUser);
}
public async Task <IActionResult> GetAllSheet(int schoolId, char projectType, int semester)
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (SqlStandardCallContext ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
PeriodData School = await timedPeriodQueries.GetLastPeriodBySchool(schoolId);
IEnumerable <AllProjectInfoData> listProject;
if (semester > 0)
{
if (projectType == 'I' || projectType == 'H')
{
listProject = await projectQueries.GetAllTypeSchoolProject(School.ChildId, projectType, semester);
}
else
{
listProject = await projectQueries.GetAllTypeSchoolProject(School.ChildId, semester);
}
}
else
{
if (projectType == 'I' || projectType == 'H')
{
listProject = await projectQueries.GetAllTypeSchoolProject(School.ChildId, projectType);
}
else
{
listProject = await projectQueries.GetAllTypeSchoolProject(School.ChildId);
}
}
if (projectType == 'I')
{
List <ProjectPiSheet> projectsSheet = new List <ProjectPiSheet>();
foreach (var item in listProject)
{
string[] place = new string[2];
place[0] = item.ClassRoom;
place[1] = item.ForumNumber.ToString();
string[] members = new string[item.UsersData.Count - 1];
string leader = "";
foreach (UserData usr in item.UsersData)
{
if (usr.UserId == item.LeaderId)
{
leader = usr.FirstName + " " + usr.LastName;
}
else
{
members[Array.IndexOf(members, null)] = usr.FirstName + " " + usr.LastName;
}
}
(string, string[])team = (leader, members);
ProjectPiSheet projectPiSheet = new ProjectPiSheet(place, item.GroupName, item.Semester, item.Sector, item.Logo, item.Slogan, item.Pitch, team, item.Technologies.ToArray());
projectsSheet.Add(projectPiSheet);
}
return(Ok(projectsSheet));
}
else if (projectType == 'H')
{
List <ProjectPfhSheet> projectsSheet = new List <ProjectPfhSheet>();
foreach (var item in listProject)
{
string[] members = new string[item.UsersData.Count - 1];
string leader = "";
foreach (UserData usr in item.UsersData)
{
if (usr.UserId == item.LeaderId)
{
leader = usr.FirstName + " " + usr.LastName;
}
else
{
members[Array.IndexOf(members, null)] = usr.FirstName + " " + usr.LastName;
}
}
(string, string[])team = (leader, members);
string background = Convert.ToBase64String(new WebClient().DownloadData("https://drive.google.com/uc?id=143SNqM-rxFmDSrA7A2Wa29eu-gqhtdOn"));
ProjectPfhSheet projectPfhSheet = new ProjectPfhSheet(item.GroupName, item.Semester, "", item.Logo, item.Slogan, item.Pitch, team, background);
projectsSheet.Add(projectPfhSheet);
}
return(Ok(projectsSheet));
}
else
{
List <ProjectSheet> projectsSheet = new List <ProjectSheet>();
foreach (var item in listProject)
{
string[] members = new string[item.UsersData.Count - 1];
string leader = "";
foreach (UserData usr in item.UsersData)
{
if (usr.UserId == item.LeaderId)
{
leader = usr.FirstName + " " + usr.LastName;
}
else
{
members[Array.IndexOf(members, null)] = usr.FirstName + " " + usr.LastName;
}
}
(string, string[])team = (leader, members);
if (item.Type == "H")
{
string background = Convert.ToBase64String(new WebClient().DownloadData("https://drive.google.com/uc?id=143SNqM-rxFmDSrA7A2Wa29eu-gqhtdOn"));
ProjectPfhSheet projectPfhSheet = new ProjectPfhSheet(item.GroupName, item.Semester, "", item.Logo, item.Slogan, item.Pitch, team, background);
projectsSheet.Add(projectPfhSheet);
}
else
{
string[] place = new string[2];
place[0] = item.ClassRoom;
place[1] = item.ForumNumber.ToString();
ProjectPiSheet projectPiSheet = new ProjectPiSheet(place, item.GroupName, item.Semester, item.Sector, item.Logo, item.Slogan, item.Pitch, team, item.Technologies.ToArray());
projectsSheet.Add(projectPiSheet);
}
}
return(Ok(projectsSheet));
}
}
}
public static async Task <(UserQueries, TimedUserQueries, ProjectStudentStruct, TimedUserData)> SaveProjectPfh(
ProjectPfh project,
ProjectStudentTable projectTable,
int userId,
SqlDefaultDatabase db,
SqlStandardCallContext ctx,
string type,
ProjectUrlTable projectUrlTable,
CustomGroupTable CustomGroupTable
)
{
GroupQueries groupQueries = new GroupQueries(ctx, db);
TraitContextQueries traitContext = new TraitContextQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupData school = await groupQueries.GetIdSchoolByConnectUser(userId);
// PeriodData timePeriod = await timedPeriodQueries.GetLastPeriodBySchool(school.ZoneId);
TimedUserData timedUser = await timedUserQueries.GetTimedUser(userId, school.ZoneId);
int traitContextId = await traitContext.GetTraitContextId(type);
string email = project.team.leader;
int leaderId;
if (email == "None")
{
leaderId = 0;
}
else
{
UserData user = await userQueries.GetUserByEmail(email);
TimedUserData timedLeader = await timedUserQueries.GetTimedUser(user.UserId, school.ZoneId);
leaderId = user.UserId;
}
project.background.image = GetTomlFromGoogleDrive.GetUrlRessource(project.background.image);
ProjectStudentStruct ProjectCreate = await projectTable.CreateProjectStudent(
ctx,
userId,
school.ZoneId,
project.name.project_name,
traitContextId,
project.logo.url,
project.slogan.slogan,
project.pitch.pitch,
leaderId,
type,
project.background.image
);
foreach (var item in project.semester.semester)
{
string semester = "S0" + item.ToString();
int idSemester = await groupQueries.GetSpecificIdGroupByZoneIdAndGroupName(school.ZoneId, semester);
await CustomGroupTable.AddUserAsync(ctx, userId, idSemester, ProjectCreate.ProjectStudentId, true);
}
return(userQueries, timedUserQueries, ProjectCreate, timedUser);
}
public async Task <IActionResult> NoteProject([FromBody] NoteProjectViewModel model)
{
int userId = _authenticationInfo.ActualUser.UserId;
TimedUserNoteProjectTable timedUserNoteProjectTable = _stObjMap.StObjs.Obtain <TimedUserNoteProjectTable>();
TimedUserTable timedUserTable = _stObjMap.StObjs.Obtain <TimedUserTable>();
EvaluatesTable evaluatesTable = _stObjMap.StObjs.Obtain <EvaluatesTable>();
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
PeriodServices periodServices = new PeriodServices();
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
AclQueries aclQueries = new AclQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
//Case Change Grade by Administration ====================================================================================================================
if (model.User == ViewModels.TypeTimedUser.StaffMember)
{
if (!await periodServices.CheckInPeriod(_stObjMap, _authenticationInfo))
{
Result result = new Result(Status.Unauthorized, "A la date d'aujourd'hui votre etablissement n'est dans une aucune periode");
return(this.CreateResult(result));
}
GroupData groupData = await groupQueries.GetIdSchoolByConnectUser(userId);
if (!await aclQueries.VerifyGrantLevelByUserId(112, await aclQueries.GetAclIdBySchoolId(groupData.ParentZoneId), userId, Operator.SuperiorOrEqual))
{
Result result = new Result(Status.Unauthorized, "Vous n'etes pas autorisé à utiliser cette fonctionnalité !");
return(this.CreateResult(result));
}
await evaluatesTable.EvaluateOrUpdateGradeProject(ctx, model.JuryId, model.ProjectId, model.Grade);
return(Ok());
}
//=========================================================================================================================================================
PeriodData periodData = await timedPeriodQueries.GetLastPeriodBySchool(model.SchoolId);
TimedUserData timedUserData = await timedUserQueries.GetTimedUser(userId, periodData.ChildId);
if (timedUserData == null)
{
TimedUserStruct timedUser = await timedUserTable.CreateOrUpdateTimedUserAsyncWithType(ctx, Data.TypeTimedUser.Anon, periodData.ChildId, userId);
timedUserData = new TimedUserData
{
TimedUserId = timedUser.TimedUserId
};
await timedUserNoteProjectTable.AddOrUpdateNote(ctx, timedUserData.TimedUserId, model.ProjectId, model.Grade);
return(Ok());
}
if (model.User == ViewModels.TypeTimedUser.Jury)
{
await evaluatesTable.EvaluateOrUpdateGradeProject(ctx, model.JuryId, model.ProjectId, model.Grade);
}
else
{
await timedUserNoteProjectTable.AddOrUpdateNote(ctx, timedUserData.TimedUserId, model.ProjectId, model.Grade);
}
return(Ok());
}
}
