Telegram bot

HwProj.AuthService/HwProj.AuthService.API/ApplicationProfile.cs

@@ -8,7 +8,7 @@ public class ApplicationProfile : Profile
     {
         public ApplicationProfile()
         {
-            CreateMap<RegisterDataDTO, User>();
+            CreateMap<RegisterDataDTO, UserViewModel>();
             CreateMap<EditAccountViewModel, EditDataDTO>();
             CreateMap<RegisterViewModel, RegisterDataDTO>();
             CreateMap<EditExternalViewModel, EditDataDTO>();

HwProj.AuthService/HwProj.AuthService.API/Controllers/AccountController.cs

@@ -90,7 +90,7 @@ public async Task<IActionResult> EditExternal([FromBody] EditExternalViewModel m
 
 
         [HttpGet("findByEmail/{email}")]
-        [ProducesResponseType(typeof(User), (int)HttpStatusCode.OK)]
+        [ProducesResponseType(typeof(UserViewModel), (int)HttpStatusCode.OK)]
         public async Task<IActionResult> FindByEmail(string email)
         {
             var user = await _userManager.FindByEmailAsync(email);
@@ -99,9 +99,9 @@ public async Task<IActionResult> FindByEmail(string email)
 
         [HttpPost("getRole")]
         [ProducesResponseType(typeof(string), (int)HttpStatusCode.OK)]
-        public async Task<IActionResult> GetRolesAsync([FromBody] User user)
+        public async Task<IActionResult> GetRolesAsync([FromBody] UserViewModel userViewModel)
         {
-            var roles = await _userManager.GetRolesAsync(user);
+            var roles = await _userManager.GetRolesAsync(userViewModel);
             return Ok(roles[0]);
         }
 

HwProj.AuthService/HwProj.AuthService.API/Models/IdentityContext.cs

@@ -4,7 +4,7 @@
 
 namespace HwProj.AuthService.API.Models
 {
-    public sealed class IdentityContext : IdentityDbContext<User>
+    public sealed class IdentityContext : IdentityDbContext<UserViewModel>
     {
         public IdentityContext(DbContextOptions<IdentityContext> options)
             : base(options)

HwProj.AuthService/HwProj.AuthService.API/RoleInitializer.cs

@@ -9,7 +9,7 @@ namespace HwProj.AuthService.API
 {
     public class RoleInitializer
     {
-        public static async Task InitializeAsync(UserManager<User> userManager, RoleManager<IdentityRole> roleManager, IEventBus eventBus)
+        public static async Task InitializeAsync(UserManager<UserViewModel> userManager, RoleManager<IdentityRole> roleManager, IEventBus eventBus)
         {
             if(await roleManager.FindByNameAsync(Roles.LecturerRole) == null)
             {
@@ -26,7 +26,7 @@ public static async Task InitializeAsync(UserManager<User> userManager, RoleMana
 
             if (await userManager.FindByEmailAsync(email) == null)
             {
-                var admin = new User { 
+                var admin = new UserViewModel { 
                     Email = email,
                     Name = "Admin",
                     UserName = "Admin"

HwProj.AuthService/HwProj.AuthService.API/Services/AccountService.cs

@@ -17,13 +17,13 @@ namespace HwProj.AuthService.API.Services
     public class AccountService : IAccountService
     {
         private readonly IUserManager _userManager;
-        private readonly SignInManager<User> _signInManager;
+        private readonly SignInManager<UserViewModel> _signInManager;
         private readonly IAuthTokenService _tokenService;
         private readonly IEventBus _eventBus;
         private readonly IMapper _mapper;
 
         public AccountService(IUserManager userManager,
-            SignInManager<User> signInManager,
+            SignInManager<UserViewModel> signInManager,
             IAuthTokenService authTokenService,
             IEventBus eventBus,
             IMapper mapper)
@@ -133,7 +133,7 @@ public async Task<Result<TokenCredentials>> RegisterUserAsync(RegisterDataDTO mo
                 return Result<TokenCredentials>.Failed("Пароль должен содержать не менее 6 символов");
             }
 
-            var user = _mapper.Map<User>(model);
+            var user = _mapper.Map<UserViewModel>(model);
             user.UserName = user.Email.Split('@')[0];
 
             var createUserTask = model.IsExternalAuth
@@ -201,40 +201,40 @@ public async Task<AccountDataDto[]> GetAllStudents()
                 .ToArray();;
         }
 
-        private Task<IdentityResult> ChangeUserNameTask(User user, EditDataDTO model)
+        private Task<IdentityResult> ChangeUserNameTask(UserViewModel userViewModel, EditDataDTO model)
         {
             if (!string.IsNullOrWhiteSpace(model.Name))
             {
-                user.Name = model.Name;
+                userViewModel.Name = model.Name;
             }
             if (!string.IsNullOrWhiteSpace(model.Name))
             {
-                user.Surname = model.Surname;
+                userViewModel.Surname = model.Surname;
             }
             if (!string.IsNullOrWhiteSpace(model.Name))
             {
-                user.MiddleName = model.MiddleName;
+                userViewModel.MiddleName = model.MiddleName;
             }
 
-            return _userManager.UpdateAsync(user);
+            return _userManager.UpdateAsync(userViewModel);
         }
 
-        private Task<IdentityResult> ChangePasswordAsync(User user, EditDataDTO model)
+        private Task<IdentityResult> ChangePasswordAsync(UserViewModel userViewModel, EditDataDTO model)
         {
             return !string.IsNullOrWhiteSpace(model.NewPassword)
-                ? _userManager.ChangePasswordAsync(user, model.CurrentPassword, model.NewPassword)
+                ? _userManager.ChangePasswordAsync(userViewModel, model.CurrentPassword, model.NewPassword)
                 : Task.FromResult(IdentityResult.Success);
         }
 
-        private async Task SignIn(User user, string password)
+        private async Task SignIn(UserViewModel userViewModel, string password)
         {
-            await _signInManager.PasswordSignInAsync(user, password, false, false)
+            await _signInManager.PasswordSignInAsync(userViewModel, password, false, false)
                 .ConfigureAwait(false);
         }
 
-        private async Task<Result<TokenCredentials>> GetToken(User user)
+        private async Task<Result<TokenCredentials>> GetToken(UserViewModel userViewModel)
         {
-            return Result<TokenCredentials>.Success(await _tokenService.GetTokenAsync(user).ConfigureAwait(false));
+            return Result<TokenCredentials>.Success(await _tokenService.GetTokenAsync(userViewModel).ConfigureAwait(false));
         }
     }
 }

HwProj.AuthService/HwProj.AuthService.API/Services/AuthTokenService.cs

@@ -15,31 +15,31 @@ namespace HwProj.AuthService.API.Services
 {
     public class AuthTokenService : IAuthTokenService
     {
-        private readonly UserManager<User> _userManager;
+        private readonly UserManager<UserViewModel> _userManager;
         private readonly IConfigurationSection _configuration;
 
-        public AuthTokenService(UserManager<User> userManager, IConfiguration configuration)
+        public AuthTokenService(UserManager<UserViewModel> userManager, IConfiguration configuration)
         {
             _userManager = userManager;
             _configuration = configuration.GetSection("AppSettings");
         }
 
-        public async Task<TokenCredentials> GetTokenAsync(User user)
+        public async Task<TokenCredentials> GetTokenAsync(UserViewModel userViewModel)
         {
             var securityKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_configuration["SecurityKey"]));
             var timeNow = DateTime.UtcNow;
 
-            var userRoles = await _userManager.GetRolesAsync(user).ConfigureAwait(false);
+            var userRoles = await _userManager.GetRolesAsync(userViewModel).ConfigureAwait(false);
 
             var token = new JwtSecurityToken(
                 issuer: _configuration["ApiName"],
                 notBefore: timeNow,
                 expires: timeNow.AddMinutes(int.Parse(_configuration["ExpireInForToken"])),
                 claims: new[]
                 {
-                    new Claim("_userName", user.UserName),
-                    new Claim("_id", user.Id),
-                    new Claim(ClaimTypes.Email, user.Email),
+                    new Claim("_userName", userViewModel.UserName),
+                    new Claim("_id", userViewModel.Id),
+                    new Claim(ClaimTypes.Email, userViewModel.Email),
                     new Claim(ClaimTypes.Role, userRoles.FirstOrDefault() ?? Roles.StudentRole)
                 },
                 signingCredentials: new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256));

HwProj.AuthService/HwProj.AuthService.API/Services/IAuthTokenService.cs

@@ -6,6 +6,6 @@ namespace HwProj.AuthService.API.Services
 {
     public interface IAuthTokenService
     {
-        Task<TokenCredentials> GetTokenAsync(User user);
+        Task<TokenCredentials> GetTokenAsync(UserViewModel userViewModel);
     }
 }

HwProj.AuthService/HwProj.AuthService.API/Services/IUserManager.cs

@@ -7,17 +7,17 @@ namespace HwProj.AuthService.API.Services
 {
     public interface IUserManager
     {
-        Task<IdentityResult> CreateAsync(User user);
-        Task<IdentityResult> CreateAsync(User user, string password);
-        Task<User> FindByIdAsync(string id);
-        Task<User> FindByEmailAsync(string email);
-        Task<IdentityResult> UpdateAsync(User user);
-        Task<IdentityResult> AddToRoleAsync(User user, string role);
-        Task<IdentityResult> RemoveFromRoleAsync(User user, string role);
-        Task<IList<string>> GetRolesAsync(User user);
-        Task<bool> IsEmailConfirmedAsync(User user);
-        Task<bool> CheckPasswordAsync(User user, string password);
-        Task<IdentityResult> ChangePasswordAsync(User user, string currentPassword, string newPassword);
-        Task<IList<User>> GetUsersInRoleAsync(string role);
+        Task<IdentityResult> CreateAsync(UserViewModel userViewModel);
+        Task<IdentityResult> CreateAsync(UserViewModel userViewModel, string password);
+        Task<UserViewModel> FindByIdAsync(string id);
+        Task<UserViewModel> FindByEmailAsync(string email);
+        Task<IdentityResult> UpdateAsync(UserViewModel userViewModel);
+        Task<IdentityResult> AddToRoleAsync(UserViewModel userViewModel, string role);
+        Task<IdentityResult> RemoveFromRoleAsync(UserViewModel userViewModel, string role);
+        Task<IList<string>> GetRolesAsync(UserViewModel userViewModel);
+        Task<bool> IsEmailConfirmedAsync(UserViewModel userViewModel);
+        Task<bool> CheckPasswordAsync(UserViewModel userViewModel, string password);
+        Task<IdentityResult> ChangePasswordAsync(UserViewModel userViewModel, string currentPassword, string newPassword);
+        Task<IList<UserViewModel>> GetUsersInRoleAsync(string role);
     }
 }

HwProj.AuthService/HwProj.AuthService.API/Services/ProxyUserManager.cs

@@ -9,69 +9,69 @@ namespace HwProj.AuthService.API.Services
 {
     public class ProxyUserManager : IUserManager
     {
-        private readonly UserManager<User> _aspUserManager;
+        private readonly UserManager<UserViewModel> _aspUserManager;
 
-        public ProxyUserManager(UserManager<User> aspUserManager)
+        public ProxyUserManager(UserManager<UserViewModel> aspUserManager)
         {
             _aspUserManager = aspUserManager;
         }
 
-        public Task<IdentityResult> CreateAsync(User user)
+        public Task<IdentityResult> CreateAsync(UserViewModel userViewModel)
         {
-            return _aspUserManager.CreateAsync(user);
+            return _aspUserManager.CreateAsync(userViewModel);
         }
 
-        public Task<IdentityResult> CreateAsync(User user, string password)
+        public Task<IdentityResult> CreateAsync(UserViewModel userViewModel, string password)
         {
-            return _aspUserManager.CreateAsync(user, password);
+            return _aspUserManager.CreateAsync(userViewModel, password);
         }
 
-        public Task<User> FindByIdAsync(string id)
+        public Task<UserViewModel> FindByIdAsync(string id)
         {
             return _aspUserManager.FindByIdAsync(id);
         }
 
-        public Task<User> FindByEmailAsync(string email)
+        public Task<UserViewModel> FindByEmailAsync(string email)
         {
             return _aspUserManager.FindByEmailAsync(email);
         }
 
-        public Task<IdentityResult> UpdateAsync(User user)
+        public Task<IdentityResult> UpdateAsync(UserViewModel userViewModel)
         {
-            return _aspUserManager.UpdateAsync(user);
+            return _aspUserManager.UpdateAsync(userViewModel);
         }
 
-        public Task<IdentityResult> AddToRoleAsync(User user, string role)
+        public Task<IdentityResult> AddToRoleAsync(UserViewModel userViewModel, string role)
         {
-            return _aspUserManager.AddToRoleAsync(user, role);
+            return _aspUserManager.AddToRoleAsync(userViewModel, role);
         }
 
-        public Task<IdentityResult> RemoveFromRoleAsync(User user, string role)
+        public Task<IdentityResult> RemoveFromRoleAsync(UserViewModel userViewModel, string role)
         {
-            return _aspUserManager.RemoveFromRoleAsync(user, role);
+            return _aspUserManager.RemoveFromRoleAsync(userViewModel, role);
         }
 
-        public Task<IList<string>> GetRolesAsync(User user)
+        public Task<IList<string>> GetRolesAsync(UserViewModel userViewModel)
         {
-            return _aspUserManager.GetRolesAsync(user);
+            return _aspUserManager.GetRolesAsync(userViewModel);
         }
 
-        public Task<bool> IsEmailConfirmedAsync(User user)
+        public Task<bool> IsEmailConfirmedAsync(UserViewModel userViewModel)
         {
-            return _aspUserManager.IsEmailConfirmedAsync(user);
+            return _aspUserManager.IsEmailConfirmedAsync(userViewModel);
         }
 
-        public Task<bool> CheckPasswordAsync(User user, string password)
+        public Task<bool> CheckPasswordAsync(UserViewModel userViewModel, string password)
         {
-            return _aspUserManager.CheckPasswordAsync(user, password);
+            return _aspUserManager.CheckPasswordAsync(userViewModel, password);
         }
 
-        public Task<IdentityResult> ChangePasswordAsync(User user, string currentPassword, string newPassword)
+        public Task<IdentityResult> ChangePasswordAsync(UserViewModel userViewModel, string currentPassword, string newPassword)
         {
-            return _aspUserManager.ChangePasswordAsync(user, currentPassword, newPassword);
+            return _aspUserManager.ChangePasswordAsync(userViewModel, currentPassword, newPassword);
         }
 
-        public Task<IList<User>> GetUsersInRoleAsync(string role)
+        public Task<IList<UserViewModel>> GetUsersInRoleAsync(string role)
         {
             return _aspUserManager.GetUsersInRoleAsync(role);
         }

HwProj.AuthService/HwProj.AuthService.API/Startup.cs

@@ -64,7 +64,7 @@ public void ConfigureServices(IServiceCollection services)
             services.AddDbContext<IdentityContext>(options =>
                 options.UseSqlServer(connectionString));
 
-            services.AddIdentity<User, IdentityRole>(opts =>
+            services.AddIdentity<UserViewModel, IdentityRole>(opts =>
                 {
                     opts.User.RequireUniqueEmail = true;
                     opts.Password.RequiredLength = 6;
@@ -74,7 +74,7 @@ public void ConfigureServices(IServiceCollection services)
                     opts.Password.RequireDigit = false;
                 })
                 .AddEntityFrameworkStores<IdentityContext>()
-                .AddUserManager<UserManager<User>>()
+                .AddUserManager<UserManager<UserViewModel>>()
                 .AddRoleManager<RoleManager<IdentityRole>>()
                 .AddDefaultTokenProviders();
 
@@ -91,7 +91,7 @@ public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 
             using (var scope = app.ApplicationServices.CreateScope())
             {
-                var userManager = scope.ServiceProvider.GetService(typeof(UserManager<User>)) as UserManager<User>;
+                var userManager = scope.ServiceProvider.GetService(typeof(UserManager<UserViewModel>)) as UserManager<UserViewModel>;
 
                 var rolesManager = scope.ServiceProvider.GetService(typeof(RoleManager<IdentityRole>)) as RoleManager<IdentityRole>;
                 var eventBus = scope.ServiceProvider.GetService<IEventBus>();

HwProj.AuthService/HwProj.AuthService.Client/AuthServiceClient.cs

@@ -134,7 +134,7 @@ public async Task<string> FindByEmailAsync(string email)
             };
 
             var response = await _httpClient.SendAsync(httpRequest);
-            var user = await response.DeserializeAsync<User>();
+            var user = await response.DeserializeAsync<UserViewModel>();
             return user?.Id;
         }
 

HwProj.Common/HwProj.Models/AuthService/ViewModels/User.cs → HwProj.Common/HwProj.Models/AuthService/ViewModels/UserViewModel.cs

@@ -2,7 +2,7 @@
 
 namespace HwProj.Models.AuthService.ViewModels
 {
-    public class User : IdentityUser
+    public class UserViewModel : IdentityUser
     {
         public string GitHubId { get; set; }
 
@@ -14,7 +14,7 @@ public class User : IdentityUser
 
         public bool IsExternalAuth { get; set; }
 
-        public User()
+        public UserViewModel()
         {
         }
     }

HwProj.Common/HwProj.Models/TelegramBotService/UserTelegram.cs

@@ -0,0 +1,27 @@
+using HwProj.Repositories;
+
+namespace HwProj.Models.TelegramBotService
+{
+    public class UserTelegram : IEntity<long>
+    {
+        public long Id { get; set; }
+
+        public long ChatId { get; set; }
+
+        public string AccountId { get; set; }
+
+        public bool IsLecture { get; set; }
+
+        public bool IsRegistered { get; set; }
+
+        public string? Code { get; set; }
+
+        public string? Comment { get; set; }
+
+        public long? TaskIdToSend { get; set; }
+
+        public string? GitHubUrl { get; set; }
+
+        public string? Operation { get; set; }
+    }
+}

HwProj.Common/HwProj.Utils/Configuration/StartupExtensions.cs

@@ -78,6 +78,7 @@ public static IServiceCollection ConfigureHwProjServices(this IServiceCollection
 
             services.AddTransient<NoApiGatewayMiddleware>();
 
+
             services.AddHttpContextAccessor();
 
             return services;