public async Task <IActionResult> AddUser()
{
string email = HttpContext.Request.Form["email"];
string name = HttpContext.Request.Form["Name"];
string surname = HttpContext.Request.Form["Surname"];
string login = HttpContext.Request.Form["Login"];
string password = HttpContext.Request.Form["Password"];
string userTyp = HttpContext.Request.Form["userTyp"];
using (var context = new RealEstateOfficeContext())
{
var usr = new Domain.User();
usr.Emailaddress = email;
usr.Name = name;
usr.Surname = surname;
usr.Login = login;
usr.Password = UserDatabaseContext.codePassword(password);
usr.UserType = Convert.ToInt32(userTyp);
context.Add(usr);
await context.SaveChangesAsync();
}
return(RedirectToAction("Index", "Users"));
}
public LoginModel(ILogger <LoginModel> logger, UserDatabaseContext userDatabaseContext,
SignInManager <IdentityUser> signInManager)
{
_logger = logger;
_userDatabaseContext = userDatabaseContext;
_signInManager = signInManager;
}
/// <summary>
/// 删除教师班级
/// </summary>
/// <param name="classId"></param>
/// <param name="m"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostDeleteTeacherClassAsync([FromBody] DeleteTeacherClassViewModel model)
{
if (!TryValidateModel(model))
{
return(BadRequest(ModelState));
}
var entity = await UserDatabaseContext.TeacherClasses
.FirstOrDefaultAsync(e => e.ClassId == model.ClassId && e.TeacherId == CurUserId).ConfigureAwait(false);
if (entity == null)
{
return(NotFound());
}
var classInfo = await UserClient.GetSchoolClassByIdAsync(new UserGrpcService.IdReq {
Id = entity.ClassId
});
if (!classInfo.Name.Equals(model.ClassName))
{
AddModelError("不正确的班级名称输入");
return(BadRequest(ModelState));
}
UserDatabaseContext.TeacherClasses.Remove(entity);
await UserDatabaseContext.SaveChangesAsync().ConfigureAwait(false);
return(new OkResult());
}
public IActionResult LoginUser()
{
string login = HttpContext.Request.Form["Login"];
string password = HttpContext.Request.Form["Password"];
string SessionName = login;
var typUser = 0;
var userid = 0;
typUser = UserDatabaseContext.Login(login, password, 1);
userid = UserDatabaseContext.Login(login, password, 2);
HttpContext.Session.SetString(Appsettings.SESSIONLOGIN, login);
HttpContext.Session.SetString(Appsettings.SESSIONTYPUSER, Convert.ToString(typUser));
HttpContext.Session.SetString(Appsettings.SESSIONLOGINID, Convert.ToString(userid));
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Role, ((Models.User.UserType)typUser).ToString()),
};
var identity = new ClaimsIdentity(claims, "identity");
var userPrincipal = new ClaimsPrincipal(new[] { identity });
//-----------------------------------------------------------
HttpContext.SignInAsync(userPrincipal);
return(RedirectToAction("Index", "Home"));
}
/// <summary>
/// 添加教师班级
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostAddTeacherClassAsync(
[FromBody] Study.Services.UserService.Req.AddTeacherClassDto addTeacherClassModel)
{
addTeacherClassModel.TeacherId = CurUserId;
if (!TryValidateModel(addTeacherClassModel))
{
return(BadRequest(ModelState));
}
var exist = await UserDatabaseContext.TeacherClasses
.AnyAsync(e => e.ClassId == addTeacherClassModel.ClassId && e.TeacherId == CurUserId)
.ConfigureAwait(false);
if (exist)
{
AddModelError("已经存在班级");
return(BadRequest(ModelState));
}
await UserDatabaseContext.TeacherClasses.AddAsync(new TeacherClass
{
TeacherId = addTeacherClassModel.TeacherId,
ClassId = addTeacherClassModel.ClassId
});
await UserDatabaseContext.SaveChangesAsync().ConfigureAwait(false);
return(new OkResult());
}
/// <summary>
/// 添加教师班级
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostAddTeacherClassAsync([FromBody] AddTeacherClassDto dto)
{
if (!TryValidateModel(dto))
{
return(BadRequest(ModelState));
}
var exist = await UserDatabaseContext.TeacherClasses
.AnyAsync(e => e.TeacherId == CurUserId && e.ClassId == dto.ClassId)
.ConfigureAwait(false);
if (exist)
{
ModelState.AddModelError(string.Empty, "重复添加");
return(BadRequest(ModelState));
}
await UserDatabaseContext.TeacherClasses.AddAsync(new Database.Entity.UserEntities.TeacherClass
{
TeacherId = CurUserId,
ClassId = dto.ClassId
});
int rows = await UserDatabaseContext.SaveChangesAsync().ConfigureAwait(false);
if (rows == 0)
{
ModelState.AddModelError(string.Empty, "没有添加任何记录");
return(BadRequest(ModelState));
}
return(new OkResult());
}
public TaskService(UserDatabaseContext context,
ICourseService courseService,
IHttpContextAccessor httpContextAccessor)
: base(httpContextAccessor)
{
this.context = context;
this.courseService = courseService;
}
public ArticlesService(UserDatabaseContext db,
//IUserService userService,
CacheService cacheService)
{
this.db = db;
// this.userService = userService;
this.cacheService = cacheService;
}
public MovieService(UserDatabaseContext context,
IDataProtectionProvider provider,
CacheService cacheService,
VideoDbContext videoDbContext)
{
this.videoDbContext = videoDbContext;
this.context = context;
this.cacheService = cacheService;
protector = provider.CreateProtector("movie");
}
public static UserDatabaseContext GetContextWithData()
{
var options = new DbContextOptionsBuilder <UserDatabaseContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
var context = new UserDatabaseContext(options);
var user1 = new User
{
Id = 1,
FirstName = "Thomas",
LastName = "Desmond",
Address = "123 Main Street",
Age = 0,
Interests = "Biking, Hiking, Camping, Motorcycles",
Picture = "fakePath/image1.png"
};
var user2 = new User
{
Id = 2,
FirstName = "Thomas",
LastName = "Smith",
Address = "851 Jefferson",
Age = 70,
Interests = "All the fun things",
Picture = "fakePath/image2.png"
};
var user3 = new User
{
Id = 3,
FirstName = "Dustin",
LastName = "Franks",
Address = "770 Arrow Street",
Age = 30,
Interests = "Video Games",
Picture = "fakePath/image3.png"
};
context.User.Add(user1);
context.User.Add(user2);
context.User.Add(user3);
context.SaveChanges();
return(context);
}
public IActionResult Login(UserPassModel userPass)
{
//string userString = HttpContext.Session.GetString("user");
if (userPass.username == null)
{
ModelState.Remove("username");
ModelState.Remove("password");
//auto sign in
return(View("Login"));
}
else
{
if (ServerSideValidation.ValidateInfo(userPass))
{
if (UserDatabaseContext.Login(userPass))
{
//Use Db context to validate user name and pass
TempData["User"] = userPass.username;
User user = new User();
user.username = userPass.username;
user.accessToken = UserDatabaseContext.GenerateAccessToken(userPass.username);
HttpContext.Session.SetString("user", JsonConvert.SerializeObject(user));
return(RedirectToAction("Index"));
}
else
{
TempData["err"] = "Invalid username or password";
return(View());
}
}
return(View());
}
}
public IActionResult Register(RegisterUserModel registerUser)
{
if (registerUser.username == null)
{
ModelState.Remove("username");
ModelState.Remove("password");
ModelState.Remove("confirmPassword");
return(View("Register"));
}
else
{
//User Db context to register user
if (UserDatabaseContext.CheckUsername(registerUser.username))
{
UserDatabaseContext.Register(registerUser);
User user = new User();
user.username = registerUser.username;
user.accessToken = UserDatabaseContext.GenerateAccessToken(registerUser.username);
HttpContext.Session.SetString("user", JsonConvert.SerializeObject(user));
}
else
{
TempData["err"] = "Username already exists";
return(View("Register"));
}
}
UserPassModel userPass = new UserPassModel();
userPass.username = registerUser.username;
userPass.password = registerUser.password;
return(RedirectToAction("Login", userPass));
}
public PostgreSQLFileConfigurationRepository(IConfiguration configuration, UserDatabaseContext userDatabaseContext)
{
_configuration = configuration;
_userDatabaseContext = userDatabaseContext;
}
public UsersController(UserDatabaseContext context)
{
_context = context;
}
public UserRepository(IServiceProvider serviceProvider)
{
serviceScope = serviceProvider.CreateScope();
userDatabaseContext = serviceScope.ServiceProvider.GetRequiredService <UserDatabaseContext>();
}
public UserService(UserDatabaseContext context, CacheService cacheService, IHttpContextAccessor httpContextAccessor)
: base(httpContextAccessor)
{
this.context = context;
this.cacheService = cacheService;
}
public UserActorController(ILogger <UserActorController> logger, UserDatabaseContext userDatabaseContext)
{
Log = new DefaultLog(logger);
UserDatabase = userDatabaseContext;
UserDatabase.Database.EnsureCreated();
}
public UserService(UserDatabaseContext context, IConfiguration config, IOptions <Audience> settings)
{
_dbcontext = context;
_config = config;
this._settings = settings;
}
public UserBusinessContext()
{
UserDBContext = new UserDatabaseContext();
}
public IdentityResourceService(UserDatabaseContext userDatabaseContext)
{
_userDatabaseContext = userDatabaseContext;
}
/// <summary>
/// Initializes a new instance of the <see cref="EmployeeRepository"/> class.
/// </summary>
/// <param name="userDbContext">The userDbContext</param>
public EmployeeRepository(UserDatabaseContext userDbContext)
{
this.userDbContext = userDbContext;
}
public IActionResult Index()
{
var model = UserDatabaseContext.ListOfUser();
return(View(model));
}
public ClientService(UserDatabaseContext userDatabaseContext)
{
_userDatabaseContext = userDatabaseContext;
}
public ApiScopeService(UserDatabaseContext userDatabaseContext)
{
_userDatabaseContext = userDatabaseContext;
}
public OcelotConfigService(UserDatabaseContext userDatabaseContext)
{
_userDatabaseContext = userDatabaseContext;
}
public RoleService(UserDatabaseContext userDatabaseContext)
{
_userDatabaseContext = userDatabaseContext;
}
public CourseService(UserDatabaseContext db, IMemoryCache cache)
{
this.db = db;
this.cache = cache;
}
public UserService(UserDatabaseContext userDatabaseContext, IConfiguration configuration)
{
_userDatabaseContext = userDatabaseContext;
_configuration = configuration;
}
