// GET: HelpQueue/HelpQueue/{id?}
        public async Task <ActionResult> Queue(int?id)
        {
            var service = new CohortService(User.Identity.GetUserId());

            CohortDetail model = null;

            if (User.IsInRole("Student"))
            {
                model = await service.GetUserCohortDetailAsync(User.Identity.GetUserId());

                if (model is null)
                {
                    return(RedirectToAction(nameof(InactiveAccount)));
                }
            }
            else if (id.HasValue)
            {
                model = await service.GetCohortById(id.Value);
            }

            if (model is null)
            {
                return(RedirectToAction(nameof(Index)));
            }

            return(View(model));
        }
        /// <summary>
        /// AJAX to this method to update existing groups with students
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public async Task<string> UpdateGroup(CohortActionObject obj)
        {
            try
            {
                var cs = new CohortService(Session["access_token"].ToString());
                var cohort = UpdateCohort(cs, obj.cohort); //1) update cohort
                var newStudentsAssociations = CreateMultipleAssociation(cs, obj.cohort.id, obj.studentsToCreate); //2) create student cohort association
                var cohortCustom = cs.UpdateCohortCustom(obj.cohort.id, JsonConvert.SerializeObject(obj.custom)); //3) update cohort custom entity

                //Get a list of the current studentCohortAssociations so that we have the ids to delete them from group
                var currentStudentCohortAssociation = await cs.GetStudentCohortAssociationsByCohortId(obj.cohort.id);
                //get the studentCohortAssociationId for students to delete
                var associationToDelete = (from s in obj.studentsToDelete select (from csca in currentStudentCohortAssociation where csca.studentId == s.id select csca.id).Single());
                //delete the studentCohortAssociation
                var removeStudents = DeleteMultipleAssociation(cs, associationToDelete); 

                await Task.WhenAll(newStudentsAssociations, cohortCustom, removeStudents);

                return "Success";
            }
            catch (Exception e)
            {
                //handle
                throw;
            }
            
        }
 /// <summary>
 /// Create a StudentCohortAssociation object
 /// </summary>
 /// <param name="cs">the service to use for this action</param>
 /// <param name="associations">the StudentCohortAssociation to create</param>
 /// <returns>result of this action</returns>
 public static async Task<ActionResponseResult> CreateOneStudentCohortAssociation(CohortService cs, string cId, string sId)
 {
     var a = new StudentCohortAssociation { cohortId = cId, studentId = sId, beginDate = DateTime.Now };
     var result = await cs.CreateStudentCohortAssociation(a);
     var student = (StudentDisplayObject)HttpContext.Current.Cache[sId];
     return GlobalHelper.GetActionResponseResult(sId, student != null ? student.name : "", result, HttpStatusCode.Created);
 }
Esempio n. 4
0
        public IHttpActionResult GetAllCohort()
        {
            CohortService cohortService = CreateCohortService();
            var           cohorts       = cohortService.GetCohorts();

            return(Ok(cohorts));
        }
Esempio n. 5
0
        public IHttpActionResult GetCohort(int id)
        {
            CohortService cohortService = CreateCohortService();
            var           cohorts       = cohortService.GetCohortById(id);

            return(Ok(cohorts));
        }
Esempio n. 6
0
        private CohortService CreateCohortService()
        {
            var userId        = Guid.Parse(User.Identity.GetUserId());
            var cohortService = new CohortService(userId);

            return(cohortService);
        }
        public async Task <ActionResult> Register()
        {
            var service = new CohortService();

            ViewBag.CohortId = new SelectList(await service.GetCohortListAsync(), "Id", "Name");
            return(View());
        }
        internal string CURRENT_ED_ORG_ID = ConfigurationManager.AppSettings["CurrentEdgOrgId"]; //there's no data from inBloom about the current user Ed Org, temporarily using a constant value for each environment

        /// <summary>
        /// Create new student cohort associations
        /// </summary>
        /// <param name="obj">cohort to create</param>
        /// <param name="cs">cohort service</param>
        /// <returns>result of this action</returns>
        public static Task<IEnumerable<ActionResponseResult>> GetNewStudentCohortAssociations(CohortActionObject obj, CohortService cs)
        {
            Task<IEnumerable<ActionResponseResult>> newStudentsAssociations;
            if (obj.studentsToCreate != null && obj.studentsToCreate.Count() > 0)
                newStudentsAssociations = CohortActionHelper.CreateMultipleStudentCohortAssociations(cs, obj.cohort.id, obj.studentsToCreate);
            else
                newStudentsAssociations = null;
            return newStudentsAssociations;
        }
 private static async Task<string> GetCohortCustomByCohortId(CohortService cs, string cohortId)
 {
     try
     {
         var result = await cs.GetCustomById(cohortId);
         return result;
     }
     catch (Exception ex)
     {
         //when there isn't a custom yet, SLC throw a 404
         return "";
     }
     
 }
        public static async Task<CohortDisplayObject> GetCohortDisplayObject(CohortService cs, Cohort cohort)
        {
            var students = GetStudentsByCohortId(cs, cohort.id);
            var custom = GetCohortCustomByCohortId(cs, cohort.id);

            await Task.WhenAll(students, custom);

            var displayObject = new CohortDisplayObject();
            displayObject.cohort = cohort;
            displayObject.students = from s in students.Result select s.id;
            displayObject.custom = JsonConvert.DeserializeObject<CohortCustom>(custom.Result); ;

            return displayObject;
        }
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    UserName  = model.Email,
                    Email     = model.Email,
                    FirstName = model.FirstName,
                    LastName  = model.LastName
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    UserManager.AddToRole(user.Id, "Student");

                    using (var ctx = new ApplicationDbContext())
                    {
                        ctx.Enrollments.Add(new EnrollmentEntity
                        {
                            StudentId = user.Id,
                            CohortId  = model.CohortId,
                            IsActive  = false
                        });
                        ctx.SaveChanges();
                    }

                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    // For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
                    // Send an email with this link
                    // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                    // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");

                    return(RedirectToAction("Index", "Home"));
                }
                AddErrors(result);
            }

            var service = new CohortService();

            ViewBag.CohortId = new SelectList(await service.GetCohortListAsync(), "Id", "Name");

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
        /// <summary>
        /// AJAX to this method to create brand new groups with students
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public async Task<string> CreateGroup(CohortActionObject obj)
        {
            try
            {
                var cs = new CohortService(Session["access_token"].ToString());
                var cohortId = await CreateCohort(cs, obj.cohort); //1) create the cohort first and retrieve the Id of the new cohort
                var studentsAssociations = CreateMultipleAssociation(cs, cohortId, obj.studentsToCreate); //2) start creating student cohort association
                var cohortCustom = cs.CreateCohortCustom(cohortId, JsonConvert.SerializeObject(obj.custom)); //3) initial populate of the cohort custom entity

                await Task.WhenAll(studentsAssociations, cohortCustom);

                return cohortId;
            }
            catch (Exception e)
            {
                //handle
                throw;
            }            
        }
        /// <summary>
        /// Get all information about a cohort
        /// </summary>
        /// <param name="cs"></param>
        /// <param name="cohort"></param>
        /// <returns></returns>
        public static async Task<CohortDisplayObject> GetCohortDisplayObject(CohortService cs, Cohort cohort)
        {
            //check to see if the item is already in cache. if so, return the cache item
            var cache = (CohortDisplayObject)HttpContext.Current.Cache[cohort.id];
            if (cache != null)
                return cache;

            var students = GetStudentsByCohortId(cs, cohort.id);
            var custom = GetCohortCustomByCohortId(cs, cohort.id);

            await Task.WhenAll(students, custom);

            var displayObject = new CohortDisplayObject();
            displayObject.cohort = cohort;
            displayObject.students = from s in students.Result select s.id;
            displayObject.custom = JsonConvert.DeserializeObject<CohortCustom>(custom.Result); ;

            HttpContext.Current.Cache.Insert(cohort.id, displayObject);
            return displayObject;
        }
 public void DeleteCohort(string id)
 {
     try
     {
         var c = new CohortService(Session["access_token"].ToString());
         var result = c.DeleteById(id);
         //return result;
         Response.Redirect(MAIN);
     }
     catch
     {
         throw;
     }            
     //throw new Exception("break here");
 }
        public async Task<IEnumerable<Cohort>> GetCohorts(){
            var c = new CohortService(Session["access_token"].ToString());
            var cohorts = await c.GetAll();

            return cohorts;
        }
        public async Task<string> DeleteOneAssociation(CohortService cs, string associationId)
        {
            var result = await cs.DeleteStudentCohortAssociationById(associationId);

            return result.ToString();
        }
        /// <summary>
        /// Update the Result object after custom has been updated through inBloom
        /// </summary>
        /// <param name="cohortResult">Result object to update</param>
        /// <param name="cohortCustom">the inBloom response message</param>
        /// <param name="successStatus">HttpStatusCode that indicates a successful response</param>
        public static void ProcessCustomResult(Result cohortResult, Task<HttpResponseMessage> m, HttpStatusCode successStatus, 
                                                CohortCustom cohortCustom = null, CohortService cs = null)
        {
            //If not found meaning cohort doesn't have a custom entity created yet
            if (m.Result.StatusCode == HttpStatusCode.NotFound)
            {
                var result = CreateCustom(cohortCustom, cs);
                ProcessCustomResult(cohortResult, result, HttpStatusCode.Created);
            }
            else
            {
                //Found the custom entity, process response from the custom entity update
                var customResult = GlobalHelper.GetActionResponseResult(cohortResult.objectActionResult.objectId,
                                                cohortResult.objectActionResult.objectName, m.Result, successStatus);
                if (m.Result.StatusCode != successStatus)
                    cohortResult.completedSuccessfully = false;

                cohortResult.customActionResult = customResult;
            }           
        }
 private static async Task<IEnumerable<Student>> GetStudentsByCohortId(CohortService cs, string cohortId)
 {
     var result = await cs.GetStudentsByCohortId(cohortId);
     return result;
 }
 public static Task<HttpResponseMessage> CreateCustom(CohortCustom custom, CohortService cs)
 {
     if (custom == null) custom = new CohortCustom { lastModifiedDate = DateTime.UtcNow };
     else custom.lastModifiedDate = DateTime.UtcNow;
     var cohortCustom = cs.CreateCohortCustom(custom.cohortId, JsonConvert.SerializeObject(custom));
     return cohortCustom;
 }
        public async Task<ActionResult> Group()
        {
            var accessToken = Session["access_token"];
            if (accessToken != null)
            {
                var cs = new CohortService(accessToken.ToString());
                var ss = new StudentService(accessToken.ToString());
                var ses = new SectionService(accessToken.ToString());

                var co = GetCohorts();
                var st = GetStudents();
                var se = GetSections();

                //Get the available data elements and colors
                var dataElements = GlobalHelper.InitializeDataElements();
                var colors = GlobalHelper.InitializeColors();

                await Task.WhenAll(co, st, se);

                var cohorts = Task.WhenAll(from c in co.Result select CohortHelper.GetCohortDisplayObject(cs, c));
                var students = Task.WhenAll(from s in st.Result select StudentHelper.GetStudentDisplayObject(ss, s));
                var sections = Task.WhenAll(from s in se.Result select SectionHelper.GetSectionDisplayObject(ses, s));

                await Task.WhenAll(cohorts, students, se);

                var filters = FilterHelper.InitializeFilters(sections.Result); //contruct filter values to filter students in the app
                await Task.WhenAll(dataElements, colors);

                var data = GetGroupingDisplayObject(dataElements, colors, filters, cohorts, students, sections);

                return Json(data, JsonRequestBehavior.AllowGet);
            }

            //session has expired, refresh page
            return View("Index");
        }
        /// <summary>
        /// Create a StaffCohortAssociation object
        /// </summary>
        /// <param name="cs">the service to use for this action</param>
        /// <param name="associations">the StaffCohortAssociation to create</param>
        /// <returns>result of this action</returns>
        public static async Task<ActionResponseResult> CreateOneStaffCohortAssociation(CohortService cs, string cId, string sId)
        {
            var a = new StaffCohortAssociation { cohortId = cId, staffId = sId, beginDate = DateTime.Now };
            var result = await cs.CreateStaffCohortAssociation(a);

            return GlobalHelper.GetActionResponseResult(sId, "", result, HttpStatusCode.Created);            
        }
 /// <summary>
 /// Create multiple StudentCohortAssociation object
 /// </summary>
 /// <param name="cs">the service to use for this action</param>
 /// <param name="associations">the StudentCohortAssociations to create</param>
 /// <returns>list of results</returns>
 public static async Task<IEnumerable<ActionResponseResult>> CreateMultipleStudentCohortAssociations(CohortService cs, string cId, IEnumerable<string> sl)
 {
     var result = await Task.WhenAll(from s in sl select CreateOneStudentCohortAssociation(cs, cId, s));
     return result;
 }
 /// <summary>
 /// Delete multiple StudentCohortAssociation objects
 /// </summary>
 /// <param name="cs">the service to use for this action</param>
 /// <param name="associations">the StudentCohortAssociations to delete</param>
 /// <returns>result of this action</returns>
 public static async Task<IEnumerable<ActionResponseResult>> DeleteMultipleStudentCohortAssociations(CohortService cs, IEnumerable<StudentCohortAssociation> associations)
 {
     var result = await Task.WhenAll(from a in associations select DeleteOneStudentCohortAssociation(cs, a));
     return result;
 }
 public static async Task<Task<IEnumerable<ActionResponseResult>>> DeleteStudentCohortAssocations(CohortActionObject obj, CohortService cs)
 {
     Task<IEnumerable<ActionResponseResult>> removeStudents;
     //Get a list of the current studentCohortAssociations so that we have the ids to delete them from group
     var currentStudentCohortAssociation = await cs.GetStudentCohortAssociationsByCohortId(obj.cohort.id);
     //get the studentCohortAssociationId for students to delete
     var associationToDelete = (from s in obj.studentsToDelete
                                select (currentStudentCohortAssociation.FirstOrDefault(csca => csca.studentId == s)));
     //delete the studentCohortAssociation
     removeStudents = CohortActionHelper.DeleteMultipleStudentCohortAssociations(cs, associationToDelete);
     return removeStudents;
 }
 /// <summary>
 /// Create a single cohort
 /// </summary>
 /// <returns></returns>
 public async Task<string> CreateCohort(CohortService cs, Cohort cohort) //TODO: modify to accept a cohort argument
 {
     try
     {
         //var cs = new CohortService(Session["access_token"].ToString());
         //var cohort = new Cohort();
         //var random = new Random();
         //cohort.educationOrgId = "2012dh-836f96e7-0b25-11e2-985e-024775596ac8";
         //cohort.cohortIdentifier = "ACC-TEST-COH-" + random.Next(10);
         //cohort.cohortType = SlcClient.Enum.CohortType.ExtracurricularActivity;
         var result = await cs.Create(cohort);
         //result.Headers.Location.AbsolutePath.Substring(result.Headers.Location.AbsolutePath.LastIndexOf("/") + 1)
         
         return result.Headers.Location.Segments[5]; //getting the id from header location
     }
     catch
     {
         throw;
     }           
 }
        private static async Task ProcessASuccessfulCohortCreate(CohortActionObject obj, CohortService cs, Result cohortResult, string staffId)
        {
            obj.cohort.id = cohortResult.objectActionResult.objectId;
            obj.custom.cohortId = obj.cohort.id;
            //1) start creating staff/student cohort association
            var newStudentsAssociations = CohortActionHelper.GetNewStudentCohortAssociations(obj, cs);
            var newStaffAssociation = CohortActionHelper.CreateOneStaffCohortAssociation(cs, obj.cohort.id, staffId);
            //2) initial populate of the cohort custom entity        
            var cohortCustom = CohortActionHelper.CreateCustom(obj.custom, cs);

            //contruct a list of tasks we're waiting for
            var tasksToWaitFor = new List<Task>();
            if (newStudentsAssociations != null) tasksToWaitFor.Add(newStudentsAssociations);
            if (cohortCustom != null) tasksToWaitFor.Add(cohortCustom);
            if (newStaffAssociation != null) tasksToWaitFor.Add(newStaffAssociation);

            await Task.WhenAll(tasksToWaitFor);

            if (newStudentsAssociations != null)
                CohortActionHelper.DetermineFailedToCreateFor(cohortResult, newStudentsAssociations.Result);

            //determine whether custom was created successfully
            CohortActionHelper.ProcessCustomResult(cohortResult, cohortCustom, HttpStatusCode.Created);
        }
        /// <summary>
        /// Create multiple new cohorts
        /// </summary>
        /// <param name="cohorts">new cohorts to create</param>
        /// <returns></returns>
        //public async Task<string[]> CreateCohorts(IEnumerable<Cohort> cohorts)
        //{
        //    try
        //    {
        //        var result = await Task.WhenAll(from c in cohorts select CreateCohort()); //TODO: add cohort as parameter
        //        return result;
        //    }
        //    catch (Exception ex)
        //    {
        //        throw;
        //    }
        //}

        /// <summary>
        /// Update a single cohort
        /// </summary>
        /// <returns></returns>
        public async Task<string> UpdateCohort(CohortService cs, Cohort cohort)
        {
            //var c = new CohortService(Session["access_token"].ToString());
            //var cohort = new Cohort();
            //var random = new Random();
            //cohort.id = "2012gd-cae52ab2-26f7-11e2-8acf-02786562673b";
            //cohort.educationOrgId = "2012dh-836f96e7-0b25-11e2-985e-024775596ac8";
            //cohort.cohortIdentifier = "ACC-" + DateTime.Now.Ticks.ToString().Substring(0,8);
            //cohort.cohortType = SlcClient.Enum.CohortType.ExtracurricularActivity;
            var result = await cs.Update(cohort);
            return result.ToString();
        }
 /// <summary>
 /// Update cohort custom entity
 /// </summary>
 /// <param name="obj">Cohort data to update</param>
 /// <param name="cs">Cohort Service object to update</param>
 /// <returns></returns>
 public static Task<HttpResponseMessage> UpdateCustom(CohortActionObject obj, CohortService cs)
 {
     var custom = obj.custom;
     if (custom == null) custom = new CohortCustom { lastModifiedDate = DateTime.UtcNow };
     else custom.lastModifiedDate = DateTime.UtcNow;
     var cohortCustom = cs.UpdateCohortCustom(obj.cohort.id, JsonConvert.SerializeObject(custom));
     return cohortCustom;
 }
        /// <summary>
        /// Delete one cohort
        /// </summary>
        /// <param name="obj">data object to deletes cohort</param>
        /// <returns>result of the action</returns>
        public async Task<Result> ProcessOneCohortDelete(string id)
        {
            try
            {
                var accessToken = Session["access_token"];
                if (accessToken != null)
                {
                    var cs = new CohortService(Session["access_token"].ToString());                                 

                    var cohortResult = await DeleteCohort(cs, id);
                    //remove cohort from cache after an update
                    HttpContext.Cache.Remove(id);

                    // delete the group's directory from the FTP server
                    FTPHelper.removeDir(id);

                    return cohortResult;
                }
                else
                {
                    //session has expired
                    return GlobalHelper.GetSessionExpiredResult(id);
                }
            }
            catch (Exception e)
            {
                return GlobalHelper.GetExceptionResult(id, e);
            }
        }
        //public async Task<string[]> CreateCustom(CohortCustom obj)
        //{
        //    var cs = new CohortService(Session["access_token"].ToString());
        //    var result = await cs.CreateCohortCustom
        //}

        public async Task<ActionResult> Sample()
        {

                //var displayObj = new List<CohortDisplayObject>();
                var cs = new CohortService(Session["access_token"].ToString());
                //var c = new StudentsController();
                //var students = await c.Get(Session["access_token"].ToString());
                var co = await GetCohorts();
                //var st = GetStudents();

                var displayObj = await Task.WhenAll(from c in co select CohortHelper.GetCohortDisplayObject(cs, c));
                //await Task.WhenAll(co, st);
                //var data = new Data { students = st, cohorts = co };
                //var cs = new CohortService(Session["access_token"].ToString());

                //var result = await Task.WhenAll(from c in co.Result select createMultipleAssociation(cs, c, st.Result));
                var filters = Helper.FilterHelper.InitializeFilters();
                return View(displayObj);            
        }
        /// <summary>
        /// Create one cohort
        /// </summary>
        /// <param name="obj">data object to create cohort</param>
        /// <returns>result of the action</returns>
        public async Task<Result> ProcessOneCohortCreate(CohortActionObject obj)
        {
            try
            {
                var accessToken = Session["access_token"];
                if (accessToken != null)
                {
                    var cs = new CohortService(accessToken.ToString());
                    //create the cohort first
                    var cohortResult = await CreateCohort(cs, obj.cohort);

                    //if cohort was created successfully then continue to create associations
                    if (cohortResult.completedSuccessfully)
                    {
                        var staffId = Session[INBLOOM_USER_ID].ToString();
                        await ProcessASuccessfulCohortCreate(obj, cs, cohortResult, staffId);
                    }

                    return cohortResult;
                }
                else
                {
                    //section expired
                    return GlobalHelper.GetSessionExpiredResult(obj.cohort.cohortIdentifier);
                }

            }
            catch (Exception e)
            {
                return GlobalHelper.GetExceptionResult(obj.cohort.cohortIdentifier, e);
            }
        }
 public async Task<string[]> CreateMultipleAssociation(CohortService cs, string cId, IEnumerable<Student> sl)
 {
     var result = await Task.WhenAll(from s in sl select CreateOneAssociation(cs, cId, s));
     return result;
 }
        public async Task<string> CreateOneAssociation(CohortService cs, string cId, Student s)
        {
            var a = new StudentCohortAssociation { cohortId = cId, studentId = s.id, beginDate = DateTime.Now };
            var result = await cs.CreateStudentCohortAssociation(a);

            return result.ToString();
        }
 public async Task<string[]> DeleteMultipleAssociation(CohortService cs, IEnumerable<string> associations)
 {
     var result = await Task.WhenAll(from a in associations select DeleteOneAssociation(cs, a));
     return result;
 }
        public async Task<ActionResult> Group()
        {
            var cs = new CohortService(Session["access_token"].ToString());
            var ss = new StudentService(Session["access_token"].ToString());

            var co = GetCohorts();
            var st = GetStudents();

            await Task.WhenAll(co, st);

            var cohorts = Task.WhenAll(from c in co.Result select CohortHelper.GetCohortDisplayObject(cs, c));
            var students = Task.WhenAll(from s in st.Result select StudentHelper.GetStudentDisplayObject(ss, s));

            await Task.WhenAll(cohorts, students);

            var data = new GroupingDisplayObject();
            data.cohorts = cohorts.Result;
            data.students = students.Result;
            data.filters = FilterHelper.InitializeFilters();

            return View(data);
        }
 /// <summary>
 /// Delete a StudentCohortAssociation object
 /// </summary>
 /// <param name="cs">service to use for this action</param>
 /// <param name="association">the StudentCohortAssociation to delete</param>
 /// <returns>result of this action</returns>
 public static async Task<ActionResponseResult> DeleteOneStudentCohortAssociation(CohortService cs, StudentCohortAssociation association)
 {
     var response = await cs.DeleteStudentCohortAssociationById(association.id);
     var student = (StudentDisplayObject)HttpContext.Current.Cache[association.studentId];
     return GlobalHelper.GetActionResponseResult(association.studentId, student != null ? student.name : "", response, HttpStatusCode.NoContent);
 }