public User GetById(int id)
{
return(_context.Users
.AsNoTracking()
.Where(UserQueries.GetById(id))
.FirstOrDefault());
}
public UserApiController(UserQueries queries, UserService service, IUserPermissionContext permissionContext, IEntryThumbPersister thumbPersister)
{
this.queries = queries;
this.service = service;
this.permissionContext = permissionContext;
this.thumbPersister = thumbPersister;
}
public void SetUp()
{
var hashedPass = LoginManager.GetHashedPass("already_exists", "123", 0);
userWithEmail = new User("already_exists", hashedPass, "*****@*****.**", 0)
{
Id = 123
};
userWithoutEmail = new User("no_email", "222", string.Empty, 321)
{
Id = 321
};
repository = new FakeUserRepository(userWithEmail, userWithoutEmail);
repository.Add(userWithEmail.Options);
permissionContext = new FakePermissionContext(new UserWithPermissionsContract(userWithEmail, ContentLanguagePreference.Default));
stopForumSpamClient = new FakeStopForumSpamClient();
mailer = new FakeUserMessageMailer();
data = new UserQueries(repository, permissionContext, new FakeEntryLinkFactory(), stopForumSpamClient, mailer, new FakeUserIconFactory(), new FakeObjectCache());
softBannedIPs = new HostCollection();
request = new PasswordResetRequest(userWithEmail)
{
Id = Guid.NewGuid()
};
repository.Add(request);
}
public ActionResult _Create(BusinessCreateViewModel model)
{
BusinessLiabilityListCreateViewModel liabilities = (BusinessLiabilityListCreateViewModel)HttpContext.Session["LIABILITIES"];
double totalLiabilityValue = 0;
if (liabilities != null)
{
totalLiabilityValue = liabilities.Liabilities.Sum(x => x.Value.HasValue ? x.Value.Value : 0);
}
if (BusinessQueries.CheckExistBusiness(UserQueries.GetCurrentUsername(), model.Name))
{
ModelState.AddModelError("CheckExistBusiness", "Kinh doanh này đã tồn tại, vui lòng nhập tên khác");
}
if (model.Value < totalLiabilityValue && totalLiabilityValue > 0)
{
ModelState.AddModelError("CompareBusinessValueAndLiabilityValue", "Giá trị tổng số nợ không vượt quá giá trị góp vốn kinh doanh");
}
if (ModelState.IsValid)
{
HttpContext.Session["BUSINESS"] = model;
return(Content("success"));
}
else
{
return(PartialView("_BusinessForm", model));
}
}
public ActionResult Save(BusinessCreateViewModel model)
{
if (BusinessQueries.CheckExistBusiness(UserQueries.GetCurrentUsername(), model.Name))
{
ModelState.AddModelError("CheckExistBusiness", "Kinh doanh này đã tồn tại, vui lòng nhập tên khác");
}
if (ModelState.IsValid)
{
model.Liabilities = (BusinessLiabilityListCreateViewModel)HttpContext.Session["LIABILITIES"];
string user = UserQueries.GetCurrentUsername();
int result = BusinessQueries.CreateBusiness(model, user);
if (result > 0)
{
return(Content("success"));
}
else
{
return(Content("failed"));
}
}
else
{
model.IsInDebt = false;
return(PartialView("_BusinessForm", model));
}
}
public IHttpActionResult Get(string email, string password)
{
if (string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
{
return(Unauthorized());
}
int userID = 0;
UserQueries query = new UserQueries();
try
{
userID = query.GetUserId(email);
}
catch (Exception e)
{
return(InternalServerError(e));
}
if (userID != 0)
{
string retrievedPassword = query.GetPassword(userID);
if (password.Equals(retrievedPassword))
{
return(Ok(authenticate.setToken(userID)));
}
}
return(Unauthorized());
}
public IHttpActionResult Post()
{
string email = System.Web.HttpContext.Current.Request["email"];
string password = System.Web.HttpContext.Current.Request["password"];
if (string.IsNullOrEmpty(email) || string.IsNullOrEmpty(password))
{
return(Unauthorized());
}
int userID = 0;
UserQueries query = new UserQueries();
try
{
userID = query.GetUserId(email);
}
catch (Exception e)
{
return(InternalServerError(e));
}
if (userID != 0)
{
string retrievedPassword = query.GetPassword(userID);
if (password.Equals(retrievedPassword))
{
return(Ok(authenticate.setToken(userID)));
}
}
return(Unauthorized());
}
public User GetByLogin(string userName)
{
return(_context.Users
.AsNoTracking()
.Where(UserQueries.GetByLogin(userName))
.FirstOrDefault());
}
public GetUserResult GetUser(Guid id)
{
var data = _context.Users
.Where(UserQueries.GetById(id))
.FirstOrDefault();
if (data == null)
{
return(null);
}
return(new GetUserResult
{
Id = data.Id.ToString(),
AditionalInfo = data.AditionalInfo,
CountryRegistryNumber = data.Document.CountryRegistryNumber,
StateRegistryNumber = data.Document.StateRegistryNumber,
EmailAddress = data.Email.EmailAddress,
FirstName = data.Name.FirstName,
LastName = data.Name.LastName,
MobilePhoneNumber1 = data.Phone.MobilePhoneNumber1,
MobilePhoneNumber2 = data.Phone.MobilePhoneNumber2,
PhoneNumber1 = data.Phone.PhoneNumber1,
PhoneNumber2 = data.Phone.PhoneNumber2,
City = data.Address.City,
NeighborHood = data.Address.NeighborHood,
Street = data.Address.Street,
StreetNumber = data.Address.StreetNumber,
ZipCode = data.Address.ZipCode,
UserName = data.UserAccount.UserName,
Password = data.UserAccount.DecryptPassword(),
ConfirmPassword = data.UserAccount.DecryptPassword()
});
}
public async Task <bool> CheckIfEmailExists(string email)
{
bool userExists = false;
try
{
using (SqlConnection con = new SqlConnection(this.ConnectionString))
{
SqlCommand cmd = new SqlCommand(UserQueries.CountUserByEmail(), con);
cmd.Parameters.Add("@Email", SqlDbType.VarChar, 50).Value = email;
await con.OpenAsync();
SqlDataReader reader = await cmd.ExecuteReaderAsync();
while (await reader.ReadAsync())
{
int numberOfUsers;
GetNumberOfUsers(out numberOfUsers, reader);
if (numberOfUsers > 0)
{
userExists = true;
}
}
}
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
throw ex;
}
return(userExists);
}
public async Task <bool> isMailExisting(string email, IStObjMap stObjMap)
{
try
{
SqlDefaultDatabase db = stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
using (var ctx = new SqlStandardCallContext())
{
UserQueries groupQueries = new UserQueries(ctx, db);
int exists = await groupQueries.CheckEmail(email);
if (exists != 0)
{
return(true);
}
else
{
return(false);
}
}
}
catch
{
return(false);
}
}
public async Task Handler_should_return_user_dto_with_roles(string role)
{
//Arrange
var fakeUser = new User {
Id = Guid.NewGuid().ToString()
};
var fakeUserDTO = new UserDetailsDTO {
Id = fakeUser.Id
};
IList <string> roles = new List <string> {
role
};
_userManagerMock.Setup(x => x.GetRolesAsync(fakeUser)).Returns(Task.FromResult(roles));
_userManagerMock.Setup(x => x.FindByIdAsync(fakeUser.Id)).Returns(Task.FromResult(fakeUser));
_mapperMock.Setup(x => x.Map <User, UserDetailsDTO>(fakeUser)).Returns(fakeUserDTO);
var queries = new UserQueries(_userManagerMock.Object, _mapperMock.Object);
//Act
var result = await queries.GetUserAsync(fakeUser.Id);
//Assert
Assert.Equal(fakeUserDTO, result);
Assert.True(result.Roles.Select(z => z.Name).SequenceEqual(roles));
}
public async Task Handler_should_return_users_dto()
{
//Arrange
var fakeUser = new User {
Id = Guid.NewGuid().ToString()
};
var fakeUserDbSet = new List <User> {
fakeUser
};
_identityDataContextMock.Setup(x => x.Users).ReturnsDbSet(fakeUserDbSet);
_userManagerMock.Setup(x => x.Users).Returns(_identityDataContextMock.Object.Users);
_mapperMock.Setup(x => x.Map <List <User>, List <UserListItemDTO> >(It.IsAny <List <User> >())).Returns(
(List <User> value) =>
{
return(value.Select(z => new UserListItemDTO
{
Id = z.Id
}).ToList());
});
var queries = new UserQueries(_userManagerMock.Object, _mapperMock.Object);
//Act
var result = await queries.GetUsersAsync();
//Assert
Assert.Equal(fakeUser.Id, result.First().Id);
}
public async Task <int> CheckIfUserExists(IStObjMap stObjMap, IAuthenticationInfo authenticationInfo, string mail, string userName, string firstName, string lastName)
{
using (var ctx = new SqlStandardCallContext())
{
var sqlDatabase = stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
var userTable = stObjMap.StObjs.Obtain <CustomUserTable>();
var actorEmail = stObjMap.StObjs.Obtain <ActorEMailTable>();
var basic = stObjMap.StObjs.Obtain <IBasicAuthenticationProvider>();
UserQueries userQueries = new UserQueries(ctx, sqlDatabase);
int currentIdUser = authenticationInfo.ActualUser.UserId;
int idUser = await userQueries.CheckEmail(mail);
if (idUser != 0)
{
return(idUser);
}
else
{
string tempPwd = RandomPassword();
string subject = "Vous êtes invité à rejoindre la plateforme InProject";
string mailContent = "Afin de vous connectez a la plateforme InProject voici votre mot de passe provisoire: " + tempPwd + " il est conseillé de modifier ce mot de passe lors de votre première connection";
int newUserId = await userTable.CreateUserAsync(ctx, currentIdUser, userName, firstName, lastName);
await actorEmail.AddEMailAsync(ctx, 1, newUserId, mail, true, false);
await basic.CreateOrUpdatePasswordUserAsync(ctx, 1, newUserId, tempPwd);
//await _emailSender.SendMessage( mail, subject, mailContent );
return(newUserId);
}
}
}
public void SetUp()
{
userWithEmail = new User("already_exists", "123", "*****@*****.**", PasswordHashAlgorithms.Default)
{
Id = 123
};
userWithoutEmail = new User("no_email", "222", string.Empty, PasswordHashAlgorithms.Default)
{
Id = 321
};
repository = new FakeUserRepository(userWithEmail, userWithoutEmail);
repository.Add(userWithEmail.Options);
permissionContext = new FakePermissionContext(new UserWithPermissionsContract(userWithEmail, ContentLanguagePreference.Default));
stopForumSpamClient = new FakeStopForumSpamClient();
mailer = new FakeUserMessageMailer();
data = new UserQueries(repository, permissionContext, new FakeEntryLinkFactory(), stopForumSpamClient, mailer,
new FakeUserIconFactory(), null, new InMemoryImagePersister(), new FakeObjectCache(), new Model.Service.BrandableStrings.BrandableStringsManager(), new EnumTranslations());
softBannedIPs = new HostCollection();
request = new PasswordResetRequest(userWithEmail)
{
Id = Guid.NewGuid()
};
repository.Add(request);
}
public async Task GetUsers_ShouldReturnAllUsers_IfTheyExist()
{
using (ApplicationDbContext context = ApplicationDbContextHelper.GetContext())
{
// Arrange
IMapper mapper = GetAutoMapperMapper();
var userQueries = new UserQueries(context, mapper);
var user1 = new User {
Id = 1, Name = "Person1"
};
var user2 = new User {
Id = 2, Name = "Person2"
};
var user3 = new User {
Id = 3, Name = "Person3"
};
context.Users.AddRange(user1, user2, user3);
context.SaveChanges();
// Act
IEnumerable <UserDto> users = await userQueries.GetUsers();
// Assert
Assert.NotEmpty(users);
Assert.Equal(3, users.Count());
Assert.Equal(new List <int> {
1, 2, 3
}, users.Select(i => i.Id).ToList());
Assert.Equal(new List <string> {
"Person1", "Person2", "Person3"
}, users.Select(i => i.Name).ToList());
}
}
public User GetByEmail(string email)
{
return(_context.Users
.AsNoTracking()
.Where(UserQueries.GetByEmail(email))
.FirstOrDefault());
}
public UserController(
UserService service,
UserQueries data,
ArtistService artistService,
ArtistQueries artistQueries,
OtherService otherService,
IRepository repository,
UserMessageQueries messageQueries,
IPRuleManager ipRuleManager,
VdbConfigManager config,
MarkdownParser markdownParser,
ActivityEntryQueries activityEntryQueries,
LoginManager loginManager)
{
Service = service;
Data = data;
_activityEntryQueries = activityEntryQueries;
_artistQueries = artistQueries;
_artistService = artistService;
_repository = repository;
_otherService = otherService;
_messageQueries = messageQueries;
_ipRuleManager = ipRuleManager;
_config = config;
_markdownParser = markdownParser;
_loginManager = loginManager;
}
public AlbumController(AlbumService service, AlbumQueries queries, UserQueries userQueries, IEntryThumbPersister imagePersister)
{
Service = service;
this.queries = queries;
this.userQueries = userQueries;
this.imagePersister = imagePersister;
}
public User GetByUserAndPassword(string email, string password)
{
return(_context.Users
.AsNoTracking()
.Where(UserQueries.GetByEmailAndPassword(email, password))
.FirstOrDefault());
}
public User GetUser(string username)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(UserQueries.GetUser(username), connection);
connection.Open();
try
{
User u = null;
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
u = new User(
(int)reader["id"],
(string)reader["username"],
(string)reader["password"],
(string)reader["email_address"],
(bool)reader["admin"]);
}
}
return(u);
}
catch (SqlException e)
{
throw e;
}
}
}
public void Remove(Guid id)
{
var entity = _context.User.Find(UserQueries.GetUserById(id));
_context.User.Remove(entity);
_context.SaveChanges();
}
public List <UserFriend> GetWaitingUserFriends(int id)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(UserQueries.GetWatingFriends(id), connection);
connection.Open();
try
{
List <UserFriend> friends = new List <UserFriend>();
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
UserFriend uf = new UserFriend();
uf.User = GetUser((int)reader["friend"]);
uf.Pending = (bool)reader["pending"];
friends.Add(uf);
}
}
return(friends);
}
catch (SqlException e)
{
throw e;
}
}
}
public IEnumerable <string> GetUserNames()
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(UserQueries.GetUsernames(), connection);
connection.Open();
try
{
List <string> usernames = new List <string>();
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
usernames.Add((string)reader["username"]);
}
}
return(usernames);
}
catch (SqlException e)
{
throw e;
}
}
}
public async Task <IActionResult> GetAllGradeProject()
{
SqlDefaultDatabase db = _stObjMap.StObjs.Obtain <SqlDefaultDatabase>();
int userId = _authenticationInfo.ActualUser.UserId;
using (var ctx = new SqlStandardCallContext())
{
ProjectQueries projectQueries = new ProjectQueries(ctx, db);
TimedPeriodQueries timedPeriodQueries = new TimedPeriodQueries(ctx, db);
TimedUserQueries timedUserQueries = new TimedUserQueries(ctx, db);
UserQueries userQueries = new UserQueries(ctx, db);
GroupQueries groupQueries = new GroupQueries(ctx, db);
GroupData groupData = await groupQueries.GetIdSchoolByConnectUser(userId);
AclQueries aclQueries = new AclQueries(ctx, db);
if (await aclQueries.VerifyGrantLevelByUserId(112, await aclQueries.GetAclIdBySchoolId(groupData.ParentZoneId), userId, Operator.SuperiorOrEqual) == false)
{
Result result = new Result(Status.Unauthorized, "Vous n'etes pas autorisé à utiliser cette fonctionnalité !");
return(this.CreateResult(result));
}
List <ProjectInfosJuryData> projects = await projectQueries.getAllProjectsGrade(groupData.ZoneId);
List <ProjectForumResultData> listToSend = GetProjectsOfForum(projects);
return(Ok(listToSend));
}
}
public List <User> GetAcceptedFriends(int id)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand command = new SqlCommand(UserQueries.GetAcceptedFriends(id), connection);
connection.Open();
try
{
List <User> friends = new List <User>();
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
friends.Add(GetUser((int)reader["friend"]));
}
}
return(friends);
}
catch (SqlException e)
{
throw e;
}
}
}
public async Task GetSystemProfileByUserId_GivenMoreThenOneRecordIsFound_ExpectMaybeWithNothing()
{
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
var connection = new Mock <IDbConnection>();
connection.SetupDapperAsync(c => c.QueryAsync <SystemProfileDto>(
It.IsAny <string>(),
It.IsAny <DynamicParameters>(),
null, null, It.IsAny <CommandType>()))
.ReturnsAsync(() => new List <SystemProfileDto>
{
new SystemProfileDto(),
new SystemProfileDto(),
});
var dbConnectionProvider = new Mock <IConnectionProvider>();
dbConnectionProvider.Setup(x => x.GetConnection())
.Returns(() => connection.Object);
var userQueries = new UserQueries(currentAuthenticatedUserProvider.Object, dbConnectionProvider.Object);
var result = await userQueries.GetSystemProfileByUserId(Guid.NewGuid());
Assert.True(result.HasNoValue);
}
public async Task CheckForPresenceOfAuthAppForCurrentUser_GivenUserDoesExist_ExpectPresentStatus()
{
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser).Returns(
Maybe.From(
new AuthenticatedUser(TestVariables.UserId, "email-address", "first-name", "last-name") as ISystemUser));
var connection = new Mock <IDbConnection>();
connection.SetupDapperAsync(c => c.QueryAsync <PresenceCheckDto <Guid> >(
It.IsAny <string>(),
It.IsAny <DynamicParameters>(),
null, null, It.IsAny <CommandType>()))
.ReturnsAsync(() => new List <PresenceCheckDto <Guid> >
{
new PresenceCheckDto <Guid>(),
});
var dbConnectionProvider = new Mock <IConnectionProvider>();
dbConnectionProvider.Setup(x => x.GetConnection())
.Returns(() => connection.Object);
var userQueries = new UserQueries(currentAuthenticatedUserProvider.Object, dbConnectionProvider.Object);
var result = await userQueries.CheckForPresenceOfAuthAppForCurrentUser();
Assert.True(result.IsPresent);
}
public async Task GetProfileForCurrentUser_GivenOneRecordIsFound_ExpectMaybeWithMappedData()
{
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser).Returns(Maybe.From(new Mock <ISystemUser>().Object));
var connection = new Mock <IDbConnection>();
connection.SetupDapperAsync(c => c.QueryAsync <ProfileDto>(
It.IsAny <string>(),
It.IsAny <DynamicParameters>(),
null, null, It.IsAny <CommandType>()))
.ReturnsAsync(() => new List <ProfileDto>
{
new ProfileDto
{
FirstName = "first-name",
LastName = "last-name",
},
});
var dbConnectionProvider = new Mock <IConnectionProvider>();
dbConnectionProvider.Setup(x => x.GetConnection())
.Returns(() => connection.Object);
var userQueries = new UserQueries(currentAuthenticatedUserProvider.Object, dbConnectionProvider.Object);
var result = await userQueries.GetProfileForCurrentUser();
Assert.True(result.HasValue);
Assert.Equal("first-name", result.Value.FirstName);
Assert.Equal("last-name", result.Value.LastName);
}
public async Task GetDeviceInfoForCurrentUser_GivenNoDataIsFound_ExpectMaybeWithNothing()
{
var currentAuthenticatedUserProvider = new Mock <ICurrentAuthenticatedUserProvider>();
currentAuthenticatedUserProvider.Setup(x => x.CurrentAuthenticatedUser).Returns(
Maybe.From(
new AuthenticatedUser(Guid.NewGuid(), string.Empty, string.Empty, string.Empty) as ISystemUser));
var connection = new Mock <IDbConnection>();
connection.SetupDapperAsync(c => c.QueryAsync <DeviceInfoDto>(
It.IsAny <string>(),
It.IsAny <DynamicParameters>(),
null, null, It.IsAny <CommandType>()))
.ReturnsAsync(() => new List <DeviceInfoDto>());
var dbConnectionProvider = new Mock <IConnectionProvider>();
dbConnectionProvider.Setup(x => x.GetConnection())
.Returns(() => connection.Object);
var userQueries = new UserQueries(currentAuthenticatedUserProvider.Object, dbConnectionProvider.Object);
var result = await userQueries.GetDeviceInfoForCurrentUser();
Assert.True(result.HasNoValue);
}
public UserQueryResult Get([FromBody] IncomingData data)
{
var service = new UserQueries(Startup.Configuration.GetConnectionString("SqlConfidenceData"));
var result = service.Executequery(data.sqlquery);
return(result);
}
public async Task <User> GetUserById(int userId)
{
var searchedUser = new User();
try
{
using (SqlConnection con = new SqlConnection(this.ConnectionString))
{
SqlCommand cmd = new SqlCommand(UserQueries.SelectUserById(), con);
cmd.Parameters.Add("@Id", SqlDbType.Int).Value = userId;
await con.OpenAsync();
SqlDataReader rdr = await cmd.ExecuteReaderAsync();
while (await rdr.ReadAsync())
{
searchedUser.UserName = rdr["UserName"].ToString();
searchedUser.Email = rdr["Email"].ToString();
searchedUser.Id = Convert.ToInt32(rdr["Id"]);
}
con.Close();
}
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
throw ex;
}
if (string.IsNullOrEmpty(searchedUser.UserName))
{
return(null);
}
return(searchedUser);
}
public CommonForumInfo()
{
_forumQueries = DependencyResolver.Current.GetService<ForumQueries>();
_orgQueries = DependencyResolver.Current.GetService<OrganizationQueries>();
_categoryQueries = DependencyResolver.Current.GetService<CategoryQueries>();
_userQueries = DependencyResolver.Current.GetService<UserQueries>();
_contentQueries = DependencyResolver.Current.GetService<ContentQueries>();
_tagQueries = DependencyResolver.Current.GetService<TagQueries>();
}
public void SetUp() {
var hashedPass = LoginManager.GetHashedPass("already_exists", "123", 0);
userWithEmail = new User("already_exists", hashedPass, "*****@*****.**", 0) { Id = 123 };
userWithoutEmail = new User("no_email", "222", string.Empty, 321) { Id = 321 };
repository = new FakeUserRepository(userWithEmail, userWithoutEmail);
repository.Add(userWithEmail.Options);
permissionContext = new FakePermissionContext(new UserWithPermissionsContract(userWithEmail, ContentLanguagePreference.Default));
stopForumSpamClient = new FakeStopForumSpamClient();
mailer = new FakeUserMessageMailer();
data = new UserQueries(repository, permissionContext, new FakeEntryLinkFactory(), stopForumSpamClient, mailer, new FakeUserIconFactory(), new FakeObjectCache());
softBannedIPs = new HostCollection();
request = new PasswordResetRequest(userWithEmail) { Id = Guid.NewGuid() };
repository.Add(request);
}
public PostController(PostQueries postQueries, UserQueries userQueries)
{
_postQueries = postQueries;
_userQueries = userQueries;
}
public AuthenticationController(UserQueries userQueries)
{
_userQueries = userQueries;
}
public ProfileController(UserQueries userQueries)
{
_userQueries = userQueries;
}
public UserController(UserService service, UserQueries data, UserMessageQueries messageQueries)
{
Service = service;
Data = data;
this.messageQueries = messageQueries;
}
public UserProfileController(UserQueries forumUserQueries)
{
_forumUserQueries = forumUserQueries;
}
