Exemplo n.º 1
0
        public async Task <IActionResult> Register(RegisterViewModel registerModel)
        {
            //get reCAPTHCA key from appsettings.json
            // ViewData["ReCaptchaKey"] = _configuration.GetSection("GoogleReCaptcha:key").Value;

            if (ModelState.IsValid)
            {
                var uemail = context.UserRepository.FindByCondition(s => s.Email == registerModel.Email || s.Phone == registerModel.Phone);
                if (uemail.Count() > 0)
                {
                    ModelState.AddModelError("", "email has already been used or phone number already used");
                    return(View(registerModel));
                }
                registerModel.Role = "standard user";
                if (await _roleManager.FindByNameAsync(registerModel.Role) == null)  //must check if role exists every time
                {
                    await _roleManager.CreateAsync(new IdentityRole(registerModel.Role));
                }
                var user = new IdentityUser
                {
                    Email       = registerModel.Email,
                    UserName    = registerModel.Email,
                    PhoneNumber = registerModel.Phone
                };

                var result = await _userManager.CreateAsync(user, registerModel.Password);

                if (result.Succeeded)
                {
                    Models.Entities.User user1 = new Models.Entities.User
                    {
                        Email   = registerModel.Email,
                        Phone   = registerModel.Phone,
                        address = registerModel.address,
                        Name    = registerModel.Name,
                        Surname = registerModel.Surname,
                    };
                    context.UserRepository.Create(user1);
                    context.UserRepository.Save();
                    await _userManager.AddToRoleAsync(user, registerModel.Role);

                    return(RedirectToAction("Login", "Account"));
                }
                else
                {
                    string s = " ";
                    foreach (var err in result.Errors)
                    {
                        s += err.Code + " " + err.Description + "\n";
                    }
                    ModelState.AddModelError(string.Empty, "Unable to register new user " + s);
                }
            }
            else
            {
                ModelState.AddModelError(string.Empty, "Unable to register new user");
            }

            return(View(registerModel));
        }
Exemplo n.º 2
0
        public Models.Entities.User GetModel(string userid)
        {
            string sql = "select * from [User] where ID=@ID";

            OleDbParameter[] parameters = { new OleDbParameter("@ID", OleDbType.VarChar, 50) };

            parameters[0].Value = userid;

            DataSet ds = DBUtility.Query(sql, parameters);

            if (ds.Tables[0].Rows.Count > 0)
            {
                Models.Entities.User model = new Models.Entities.User();
                if (!string.IsNullOrEmpty(ds.Tables[0].Rows[0]["ID"].ToString()))
                {
                    model.ID = int.Parse(ds.Tables[0].Rows[0]["ID"].ToString());
                }
                model.UserID = ds.Tables[0].Rows[0]["UserID"].ToString();
                model.PassWord = ds.Tables[0].Rows[0]["PassWord"].ToString();
                if (!string.IsNullOrEmpty(ds.Tables[0].Rows[0]["CreateDate"].ToString()))
                {
                    model.CreateDate = DateTime.Parse(ds.Tables[0].Rows[0]["CreateDate"].ToString());
                }

                return model;
            }
            else
            {
                return null;
            }
        }
Exemplo n.º 3
0
        public ActionResult Create(TasksViewModel tvm, ProjectViewModel pvm, WebApplication1.Models.Entities.User uvm, DifficulteViewModel d)
        {
            var p = Ps.GetAll();

            foreach (var item in p)
            {
                ProjectViewModel Pvm = new ProjectViewModel();
                Pvm.projectId   = item.projectId;
                Pvm.projectname = item.projectname;
                Pvm.categoryId  = item.categoryId;
                Pvm.description = item.description;
                Pvm.plan        = item.plan;
                Pvm.goals       = item.goals;
                Pvm.state       = (WebApplication1.Models.stat)stat.To_Do;
            }
            ViewBag.pro = new SelectList(p, "projectId", "projectname");


            var u = Us.GetAll();

            foreach (var item in u)
            {
                Models.Entities.User Uvm = new Models.Entities.User();
                Uvm.Id = item.Id;
            }
            ViewBag.usr = new SelectList(u, "Id", "Id");

            var D = Ds.GetAll();

            foreach (var item in D)
            {
                DifficulteViewModel df = new DifficulteViewModel();
                df.DifficulteId = item.DifficulteId;
            }
            ViewBag.diff = new SelectList(D, "DifficulteId", "DifficulteId");

            Tasks t = new Tasks();

            t.tasksId       = tvm.taskId;
            t.projectId     = pvm.projectId;
            t.team_memberId = uvm.Id;
            // p.deadline = pvm.deadline;
            //t.duration = tvm.duration;
            //t.state = (Domain.Entities.stat)stat.To_Do;
            t.DifficulteId = d.DifficulteId;
            t.nomtask      = tvm.nomtask;
            Ts.Add(t);
            Ts.Commit();

            try
            {
                // TODO: Add insert logic here

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        private async Task <User> PerformUserCreation(Models.Entities.User userEntity)
        {
            var createdEntity = await _userRepository.CreateItemAsync(userEntity);

            var userModel = _mapper.Map <User>(createdEntity);

            return(userModel);
        }
Exemplo n.º 5
0
        private string GenerateToken(Models.Entities.User user)
        {
            var claims = GetClaims(user);

            var token = new JwtSecurityToken(
                issuer: _config["TokenOptions:Issuer"],
                audience: _config["TokenOptions:Audience"],
                claims: claims,
                expires: DateTime.UtcNow.AddMinutes(10),
                signingCredentials: SigningCredentials()
                );

            return(new JwtSecurityTokenHandler().WriteToken(token));
        }
Exemplo n.º 6
0
        // GET: User/Delete/5
        public ActionResult DeleteT(int id)
        {
            var cat = Cs.GetById(id);


            User cvm = new Models.Entities.User();

            cvm.firstName = cat.firstName;
            cvm.lastName  = cat.lastName;
            cvm.imagePath = cat.imagePath;
            cvm.Email     = cat.Email;
            cvm.Address   = cat.Address;
            cvm.gender    = cat.gender;
            return(View(cvm));
        }
Exemplo n.º 7
0
        private List <Claim> GetClaims(Models.Entities.User user)
        {
            var roleNameClaims = user.UserRoleCollection.Select(ur => new Claim("roleNames", ur.Role.Nama)).ToList();
            var roleIds        = user.UserRoleCollection.Select(ur => new Claim("roleIds", ur.Role.Id.ToString())).ToList();

            var claims = new List <Claim>();

            claims.AddRange(new List <Claim>
            {
                new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
                new Claim(JwtRegisteredClaimNames.NameId, user.Username)
            }.Union(roleNameClaims).Union(roleIds));

            return(claims);
        }
Exemplo n.º 8
0
        public async Task <IHttpActionResult> Post([FromBody] Models.Entities.User user)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    user = await _user.Post(user);

                    return(Ok(user));
                }
                return(BadRequest(ModelState));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Exemplo n.º 9
0
        public IResponseMessage Save(User user)
        {
            bool isExist = context.Users.Any(c => c.Email.Equals(user.Email));

            if (!isExist)
            {
                Models.Entities.User savedObject = user;
                savedObject.Id = Guid.NewGuid().ToString();
                var result = context.Users.Add(user);
                context.SaveChanges();
                return(new SuccessMessage <Models.ResponseModels.User>((Models.ResponseModels.User)result.Entity));
            }
            else
            {
                return(new FailureMessage());
            }
        }
Exemplo n.º 10
0
        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {
            context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
            var user = new Models.Entities.User().Authenticate(context.UserName, context.Password);

            if (user == null)
            {
                context.SetError("invalid_grant", "Usuário ou senha esta incorreto");
            }

            var identity = new ClaimsIdentity(context.Options.AuthenticationType);

            identity.AddClaim(new Claim("usr", context.UserName));
            identity.AddClaim(new Claim("role", "admin"));

            context.Validated(identity);
        }
Exemplo n.º 11
0
        // GET: Tasks/Create
        public ActionResult Create()
        {
            var p = Ps.GetAll();

            foreach (var item in p)
            {
                ProjectViewModel Cvm = new ProjectViewModel();
                Cvm.projectId   = item.projectId;
                Cvm.projectname = item.projectname;
                Cvm.categoryId  = item.categoryId;
                Cvm.description = item.description;
                Cvm.plan        = item.plan;
                Cvm.goals       = item.goals;

                Cvm.state = (WebApplication1.Models.stat)stat.To_Do;
            }
            ViewBag.pro = new SelectList(p, "projectId", "projectname");


            var u = Us.GetAll();
            List <WebApplication1.Models.Entities.User> vm = new List <WebApplication1.Models.Entities.User>();

            foreach (var item in u)
            {
                Models.Entities.User Cvm = new Models.Entities.User();
                if (item.RoleUser == "Member")
                {
                    Cvm.Id    = item.Id;
                    Cvm.Email = item.Email;
                    vm.Add(Cvm);
                }
            }
            ViewBag.usr = new SelectList(vm, "Id", "Email");

            var D = Ds.GetAll();

            foreach (var item in D)
            {
                DifficulteViewModel df = new DifficulteViewModel();
                df.DifficulteId = item.DifficulteId;
            }
            ViewBag.diff = new SelectList(D, "DifficulteId", "Nomdiff");

            return(View());
        }
        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {
            context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
            var user = new Models.Entities.User().Authenticate(context.UserName, context.Password);

            if (user == null)
            {
                context.SetError("invalid_grant", "Usuário ou senha esta incorreto");
            }

            var identity = new ClaimsIdentity(context.Options.AuthenticationType);
            identity.AddClaim(new Claim("usr", context.UserName));
            identity.AddClaim(new Claim("role", "admin"));

            context.Validated(identity);


        }
Exemplo n.º 13
0
 public IResponseMessage Create(User user)
 {
     Models.Entities.User userEntity = user;
     if (context.Users.Any(c => c.Email.Equals(userEntity.Email, StringComparison.CurrentCultureIgnoreCase) && c.Password.Equals(userEntity.Password)))
     {
         Models.Entities.UserToken userToken = new Models.Entities.UserToken()
         {
             Id        = Guid.NewGuid().ToString(),
             IsDeleted = false,
             ExpireAt  = DateTime.Now.AddDays(365),
             UserId    = userEntity.Id
         };
         context.UserTokens.Add(userToken);
         context.SaveChanges();
         return(new SuccessMessage <Models.ResponseModels.UserToken>((Models.ResponseModels.UserToken)userToken));
     }
     return(new FailureMessage());
 }
Exemplo n.º 14
0
        public ActionResult DoctorProfile()
        {
            Models.Entities.User u = Getcurrentuser();

            SqlConnection conn = new SqlConnection("Data Source=(LocalDb)\\MSSQLLocalDB;Initial Catalog=EpionneDb;Persist Security Info=True;User ID=;Password="******"Data Source = ; AttachDbFilename =| DataDirectory |\aspnet - Epione.Presentation - 20181027124435.mdf; Initial Catalog = Epione; Integrated Security = True  providerName=System.Data.SqlClient");
            conn.Open();

            SqlCommand command = new SqlCommand("Select * from [Users] where id=@zip", conn);

            //SqlCommand command = new SqlCommand("Select id from [Users] where name=@zip", conn);
            command.Parameters.AddWithValue("@zip", u.Id);

            Doctor D = new Models.Entities.Doctor();

            using (SqlDataReader reader = command.ExecuteReader())
            {
                while (reader.Read())

                {
                    int    Id   = Int32.Parse(String.Format("{0}", reader["Id"]));
                    string name = String.Format("{0}", reader["firstName"]);

                    string Adress    = String.Format("{0}", reader["Address"]);
                    string Email     = String.Format("{0}", reader["Email"]);
                    string Lname     = String.Format("{0}", reader["lastName"]);
                    string imagePath = String.Format("{0}", reader["imagePath"]);

                    D = new Doctor {
                        Id = Id, firstName = name, Address = Adress, Email = Email, lastName = Lname, imagePath = imagePath
                    };
                }

                reader.NextResult();
            }


            conn.Close();



            conn.Open();
            List <Intervention> Linter = new List <Intervention>();

            SqlCommand command2 = new SqlCommand("Select * from [Interventions] where idU=@zip", conn);

            //SqlCommand command = new SqlCommand("Select id from [Users] where name=@zip", conn);
            command2.Parameters.AddWithValue("@zip", u.Id);

            using (SqlDataReader reader = command2.ExecuteReader())
            {
                while (reader.Read())

                {
                    int    Id   = Int32.Parse(String.Format("{0}", reader["interventionId"]));
                    string name = String.Format("{0}", reader["Description"]);

                    Intervention Int = new Intervention {
                        Description = name, interventionId = Id
                    };
                    Linter.Add(Int);
                }

                reader.NextResult();
            }


            conn.Close();

            allahmed ahmed = new allahmed {
                mydoctor = D, interventionList = Linter
            };


            return(View(ahmed));
        }
Exemplo n.º 15
0
        private async Task <string> CreateRefreshToken(CancellationToken cancellationToken, Models.Entities.User user)
        {
            using (var transaction = await _ctx.Database.BeginTransactionAsync(cancellationToken))
            {
                try
                {
                    var existingRefreshToken = await _ctx.RefreshToken.SingleOrDefaultAsync(r => r.UserId == user.Id, cancellationToken);

                    if (existingRefreshToken != null)
                    {
                        _ctx.RefreshToken.Remove(existingRefreshToken);

                        await _ctx.SaveChangesAsync(cancellationToken);
                    }

                    var refreshToken = new RefreshToken
                    {
                        UserId   = user.Id,
                        Token    = Guid.NewGuid().ToString(),
                        IssuedAt = DateTime.UtcNow,
                        ExpireAt = DateTime.UtcNow.AddDays(1)
                    };

                    await _ctx.AddAsync(refreshToken, cancellationToken);

                    await _ctx.SaveChangesAsync(cancellationToken);

                    transaction.Commit();

                    return(refreshToken.Token);
                }
                catch (Exception)
                {
                    transaction.Rollback();
                    throw new Exception("Token refresh creation failed");
                }
            }
        }
Exemplo n.º 16
0
        public async Task SubmitAsync(Models.Contents.Activity activity, Models.Entities.Lecture lecture, Models.Entities.User user,
                                      Action <int?, bool, string> doneCallback = null)
        {
            try
            {
                var assign = DatabaseService.Context.LectureUsers.Include(x => x.User).Include(x => x.Lecture).ThenInclude(x => x.Owner).Where(x => x.UserId == user.Id && x.LectureId == lecture.Id).FirstOrDefault();
                if (assign == null)
                {
                    doneCallback(null, false, "The user is not assigned"); return;
                }
                var time = DateTime.Now;

                foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                {
                    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                    if (!fileInfo.Directory.Exists)
                    {
                        fileInfo.Directory.Create();
                        Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home").WaitForExit();
                    }

                    if (activity.GetFileComponents().ContainsKey(f.Name))
                    {
                        Process.Start("rm", $"-R {fileInfo.FullName}").WaitForExit();
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac)
                        {
                            if (uac.Data != null)
                            {
                                using (var w = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write))
                                {
                                    w.Write(uac.Data, 0, uac.Data.Length);
                                }
                            }
                        }
                        else
                        {
                            using (var w = new StreamWriter(fileInfo.FullName))
                            {
                                w.Write(await activity.GetFileComponents()[f.Name].GetValueAsync());
                            }
                        }
                        if (!fileInfo.Exists)
                        {
                            doneCallback(null, false, "Failure to submit. Please retry.");
                            return;
                        }
                        Process.Start("chown", $" {user.Id + 1000}:{user.Id + 1000} {fileInfo.FullName}").WaitForExit();
                        // Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home").WaitForExit();
                        Console.WriteLine($"DEBUG_LOG: SAVE FILE BEFORE SUBMIT {fileInfo.FullName}");
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac2 && uac2.Data != null)
                        {
                            uac2.SetSavedFileInfo(fileInfo);
                        }
                    }
                }

                // Check certainly saved
                //foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                //{
                //    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                //    if (!fileInfo.Exists)
                //    {
                //        doneCallback(null, false, "Failure to save. Please retry.");
                //        return;
                //    }
                //}

                assign.RepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Save before Submit\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                assign.RepositoryPair.ClonedRepository.Push();


                var submit_file = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/SUBMIT");
                var command     = $"cd ~/{activity.Directory}; {activity.Submit}";
                Queue.QueueBackgroundWorkItem(async token =>
                {
                    try
                    {
                        if (!string.IsNullOrWhiteSpace(activity.Submit))
                        {
                            var sandbox = DatabaseService.Context.LectureSandboxes.Where(x => x.Name == activity.Sandbox && x.LectureId == lecture.Id).FirstOrDefault();
                            if (sandbox == null)
                            {
                                doneCallback(null, false, "Not found sandbox"); return;
                            }

                            var sb = new System.Text.StringBuilder();
                            await sandbox.DoOnSandboxWithCmdAsync(user, command, (stdout) => { sb.AppendLine(stdout); }, null, null, (code) =>
                            {
                                using (var w = new StreamWriter(submit_file.FullName))
                                {
                                    w.Write(sb.ToString());
                                }
                            });
                            if (!submit_file.Exists)
                            {
                                doneCallback(null, false, "Failure to submit. Please retry.");
                                return;
                            }

                            assign.RepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Save Submit Summary\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                            assign.RepositoryPair.ClonedRepository.Push();
                        }


                        foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                        {
                            var fileInfo = new FileInfo($"{lecture.DirectoryPath}/submissions/{user.Account}/{activity.Name}/{f.Name}");
                            if (!fileInfo.Directory.Exists)
                            {
                                fileInfo.Directory.Create();
                            }

                            if (activity.GetFileComponents().ContainsKey(f.Name))
                            {
                                if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac)
                                {
                                    if (uac.Data != null)
                                    {
                                        using (var w = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write))
                                        {
                                            w.Write(uac.Data, 0, uac.Data.Length);
                                        }
                                    }
                                }
                                else
                                {
                                    using (var w = new StreamWriter(fileInfo.FullName))
                                    {
                                        w.Write(await activity.GetFileComponents()[f.Name].GetValueAsync());
                                    }
                                }
                            }
                            Console.WriteLine($"DEBUG_LOG: SAVE FILE OF SUBMISSION {fileInfo.FullName}");
                            if (!fileInfo.Exists)
                            {
                                doneCallback(null, false, "Failure to submit. Please retry.");
                                return;
                            }
                            if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac2 && uac2.Data != null)
                            {
                                uac2.SetSubmittedFileInfo(fileInfo);
                            }
                        }


                        if (!string.IsNullOrWhiteSpace(activity.Submit))
                        {
                            var source = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/SUBMIT");
                            var target = new FileInfo($"{lecture.DirectoryPath}/submissions/{user.Account}/{activity.Name}/SUBMIT");
                            File.Copy(source.FullName, target.FullName, true);
                            if (!target.Exists)
                            {
                                doneCallback(null, false, "Failure to submit. Please retry.");
                                return;
                            }
                        }

                        lecture.LectureSubmissionsRepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Submit\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                        lecture.LectureSubmissionsRepositoryPair.ClonedRepository.Push();

                        DatabaseService.Context.ActivityActionHistories.Add(new Models.Entities.ActivityActionHistory()
                        {
                            User         = user,
                            Lecture      = lecture,
                            ActivityName = activity.Name,
                            Directory    = activity.Directory,
                            ActionType   = Models.Entities.ActivityActionType.SaveAndSubmit,
                            DateTime     = time
                        });
                        DatabaseService.Context.SaveChanges();
                        doneCallback(null, true, "Files were submitted successfully");
                    }
                    catch
                    {
                        doneCallback(null, false, "Failure to submit. Please retry.");
                        return;
                    }
                }, user.IsTeacher(lecture));
            }
            catch (Exception e)
            {
                doneCallback(null, false, e.Message);
            }
        }
Exemplo n.º 17
0
        public async Task <(bool, string)> SaveAsync(Models.Contents.Activity activity, Models.Entities.Lecture lecture, Models.Entities.User user)
        {
            try
            {
                var assign = DatabaseService.Context.LectureUsers.Include(x => x.User).Include(x => x.Lecture).ThenInclude(x => x.Owner).Where(x => x.UserId == user.Id && x.LectureId == lecture.Id).FirstOrDefault();
                if (assign == null)
                {
                    return(false, "The user is not assigned");
                }
                var time = DateTime.Now;
                foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                {
                    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                    if (!fileInfo.Directory.Exists)
                    {
                        fileInfo.Directory.Create();
                        Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home").WaitForExit();
                    }

                    if (activity.GetFileComponents().ContainsKey(f.Name))
                    {
                        Process.Start("rm", $"-R {fileInfo.FullName}").WaitForExit();
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac)
                        {
                            if (uac.Data != null)
                            {
                                using (var w = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write))
                                {
                                    w.Write(uac.Data, 0, uac.Data.Length);
                                }
                            }
                        }
                        else
                        {
                            using (var w = new StreamWriter(fileInfo.FullName))
                            {
                                w.Write(await activity.GetFileComponents()[f.Name].GetValueAsync());
                            }
                        }

                        if (!fileInfo.Exists)
                        {
                            return(false, "Failure to save. Please retry.");
                        }
                        Process.Start("chown", $" {user.Id + 1000}:{user.Id + 1000} {fileInfo.FullName}").WaitForExit();
                        // Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home").WaitForExit();
                        Console.WriteLine($"DEBUG_LOG: SAVE FILE {fileInfo.FullName}");
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac2 && uac2.Data != null)
                        {
                            uac2.SetSavedFileInfo(fileInfo);
                        }
                    }
                }

                // Check certainly saved
                //foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                //{
                //    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                //    if(!fileInfo.Exists)
                //    {
                //        return (false, "Failure to save. Please retry.");
                //    }
                //}

                assign.RepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Save\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                assign.RepositoryPair.ClonedRepository.Push();

                DatabaseService.Context.ActivityActionHistories.Add(new Models.Entities.ActivityActionHistory()
                {
                    User         = user,
                    Lecture      = lecture,
                    ActivityName = activity.Name,
                    Directory    = activity.Directory,
                    ActionType   = Models.Entities.ActivityActionType.Save,
                    DateTime     = time
                });
                DatabaseService.Context.SaveChanges();

                return(true, "Files were saved successfully");
            }
            catch (Exception e)
            {
                return(false, e.Message);
            }
        }
Exemplo n.º 18
0
        public async Task SetInitialValueAsync(Models.Contents.Activity activity, Models.Entities.Lecture lecture, Models.Entities.User user)
        {
            foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
            {
                try
                {
                    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                    if (fileInfo.Exists && activity.GetFileComponents().ContainsKey(f.Name))
                    {
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent u)
                        {
                            u.SetSavedFileInfo(fileInfo);
                        }
                        else
                        {
                            using (var t = new StreamReader(fileInfo.FullName))
                            {
                                await activity.GetFileComponents()[f.Name].SetValueAsync(t.ReadToEnd());
                            }
                        }
                    }
                    else
                    {
                        await activity.GetFileComponents()[f.Name].SetDefaultValueAsync();
                    }
                }
                catch
                {
                    await activity.GetFileComponents()[f.Name].SetDefaultValueAsync();
                }

                try
                {
                    var submittedFileInfo = new FileInfo($"{lecture.DirectoryPath}/submissions/{user.Account}/{activity.Name}/{f.Name}");
                    if (submittedFileInfo.Exists)
                    {
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent u)
                        {
                            u.SetSubmittedFileInfo(submittedFileInfo);
                        }
                    }
                }
                catch
                {
                }
            }
        }
Exemplo n.º 19
0
        public async Task ValidateAsync(Models.Contents.Activity activity, Models.Entities.Lecture lecture, Models.Entities.User user,
                                        Action <bool?, bool, string> doneCallback = null)
        {
            try
            {
                var assign = DatabaseService.Context.LectureUsers.Include(x => x.User).Include(x => x.Lecture).ThenInclude(x => x.Owner).Where(x => x.UserId == user.Id && x.LectureId == lecture.Id).FirstOrDefault();
                if (assign == null)
                {
                    doneCallback(null, false, "The user is not assigned");
                }

                var sandbox = DatabaseService.Context.LectureSandboxes.Where(x => x.Name == activity.Sandbox && x.LectureId == lecture.Id).FirstOrDefault();
                if (sandbox == null)
                {
                    doneCallback(null, false, "Not found sandbox");
                }

                var time = DateTime.Now;
                foreach (var f in activity.GetChildRenderFragments().Select(x => x.Item1))
                {
                    var fileInfo = new FileInfo($"{user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home/{activity.Directory}/{f.Name}");
                    if (!fileInfo.Directory.Exists)
                    {
                        fileInfo.Directory.Create();
                        Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/l{lecture.Owner.Account}/ecture_data/{lecture.Name}/home").WaitForExit();
                    }

                    if (activity.GetFileComponents().ContainsKey(f.Name))
                    {
                        Process.Start("rm", $"-R {fileInfo.FullName}").WaitForExit();
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac)
                        {
                            if (uac.Data != null)
                            {
                                using (var w = new FileStream(fileInfo.FullName, FileMode.Create, FileAccess.Write))
                                {
                                    w.Write(uac.Data, 0, uac.Data.Length);
                                }
                            }
                        }
                        else
                        {
                            using (var w = new StreamWriter(fileInfo.FullName))
                            {
                                w.Write(await activity.GetFileComponents()[f.Name].GetValueAsync());
                            }
                        }

                        if (!fileInfo.Exists)
                        {
                            doneCallback(null, false, "Failure to save. Please retry.");
                            return;
                        }
                        Process.Start("chown", $" {user.Id + 1000}:{user.Id + 1000} {fileInfo.FullName}").WaitForExit();
                        // Process.Start("chown", $"-R {user.Id + 1000}:{user.Id + 1000} {user.DirectoryPath}/lecture_data/{lecture.Owner.Account}/{lecture.Name}/home").WaitForExit();
                        Console.WriteLine($"DEBUG_LOG: SAVE FILE BEFORE VALIDATION {fileInfo.FullName}");
                        if (activity.GetFileComponents()[f.Name] is UploadActivityComponent uac2 && uac2.Data != null)
                        {
                            uac2.SetSavedFileInfo(fileInfo);
                        }
                    }
                }

                assign.RepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Save before Validate\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                assign.RepositoryPair.ClonedRepository.Push();

                Queue.QueueBackgroundWorkItem(async token =>
                {
                    var accept = await(activity.Validations.Child as ALMS.App.Models.Contents.IValidatable).ValidateAsync(async validation =>
                    {
                        if (string.IsNullOrWhiteSpace(validation.Run))
                        {
                            return(false);
                        }
                        var command = $"cd ~/{activity.Directory}; {validation.Run}";
                        var stdout  = new System.Text.StringBuilder();
                        var stderr  = new System.Text.StringBuilder();
                        await sandbox.DoOnSandboxAsync(user.Account, command,
                                                       data => { stdout.AppendLine(data); }, data => { stderr.AppendLine(data); }, null, activity.Limits);

                        if (validation.Type.ToLower() == "equals")
                        {
                            return(stdout.ToString().Trim() == validation.Answer.Trim());
                        }
                        return(false);
                    });

                    try
                    {
                        assign.RepositoryPair.ClonedRepository.CommitChanges($"[Activity] Name=\"{activity.Name}\" Action=\"Validate\" DateTime=\"{time.ToString("yyyy-MM-ddTHH:mm:sszzz")}\"", user.DisplayName, user.EmailAddress);
                        assign.RepositoryPair.ClonedRepository.Push();

                        DatabaseService.Context.ActivityActionHistories.Add(new Models.Entities.ActivityActionHistory()
                        {
                            User         = user,
                            Lecture      = lecture,
                            ActivityName = activity.Name,
                            Directory    = activity.Directory,
                            ActionType   = accept ? Models.Entities.ActivityActionType.SaveAndValidateAccept : Models.Entities.ActivityActionType.SaveAndValidateReject,
                            DateTime     = time
                        });
                        DatabaseService.Context.SaveChanges();
                        doneCallback(accept, true, "Validate successfully");
                    }
                    catch (Exception e)
                    {
                        doneCallback(null, false, e.Message);
                    }
                }, user.IsTeacher(lecture));
            }
            catch (Exception e)
            {
                doneCallback(null, false, e.Message);
            }
        }