public void InsertGroupMember()
{
GroupMemberRepository groupMemberRepository = new GroupMemberRepository(new InMemoryDbContextFactory().CreateDbContext());
GroupModel groupModel = new GroupModel
{
Id = Guid.NewGuid(),
Name = "První cenová skupina",
Description = "Popisek testovací skupiny První cenová skupiina",
};
UserModel userModel = new UserModel
{
Id = Guid.NewGuid(),
Name = "Martin",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420"
};
GroupMemberModel groupMemberModel = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel,
User = userModel,
Permission = PermissionEnum.Moderator
};
groupMemberRepository.Insert(groupMemberModel);
var groupMemberRepositoryResponse = groupMemberRepository.GetById(groupMemberModel.Id);
Assert.NotNull(groupMemberRepositoryResponse);
Assert.Equal(userModel.Name, groupMemberModel.User.Name);
Assert.Equal(groupModel.Name, groupMemberModel.Group.Name);
}
public bool addFileToGroup([FromBody] string id, string username, string fileToken)
{
object[] c = { id, fileToken };
GroupFileSharingModel gfs = db.GroupFileSharings.Where(gf => gf.id == id && gf.token == fileToken).FirstOrDefault();
if (gfs != null)
{
return(false);
}
else
{
GroupMemberModel gms = db.GroupMembers.Where(gm => gm.id == id && gm.username == username).FirstOrDefault();
if (gms == null)
{
return(false);
}
FileModel file = db.Files.Find(fileToken);
if (file == null)
{
return(false);
}
gfs = new GroupFileSharingModel();
gfs.id = id;
//gfs.file = file;
//gfs.group = db.Groups.Find(gId);
gfs.token = fileToken;
db.GroupFileSharings.Add(gfs);
db.SaveChanges();
return(true);
}
}
public GroupMemberModel GetMemberModel(string groupName, User user)
{
GroupMemberModel model = new GroupMemberModel();
model.FullName = user.FullName;
model.Name = user.Name;
bool isMember = user.Groups.Contains(groupName, StringComparer.CurrentCultureIgnoreCase);
model.CanAdd = !isMember;
model.CanRemove = isMember;
return model;
}
private void AddUser()
{
GroupMemberModel groupMember = new GroupMemberModel();
groupMember.Id = Guid.NewGuid();
groupMember.User.Id = userRepository.GetById(LoggedUserID.selectedUserModel.Id).Id;
groupMember.Group.Id = groupRepository.GetById(LoggedUserID.actualGroupModel.Id).Id;
groupMember.Permission = DAL.Enums.PermissionEnum.User;
groupMemberRepository.Insert(groupMember);
}
public GroupMemberModel GetMemberModel(string groupName, User user)
{
GroupMemberModel model = new GroupMemberModel();
model.FullName = user.FullName;
model.Name = user.Name;
bool isMember = user.Groups.Contains(groupName, StringComparer.CurrentCultureIgnoreCase);
model.CanAdd = !isMember;
model.CanRemove = isMember;
return(model);
}
public void InsertReaction()
{
ReactionRepository reactionRepository = new ReactionRepository(new InMemoryDbContextFactory().CreateDbContext());
UserModel userModel = new UserModel
{
Id = Guid.NewGuid(),
Name = "Peter",
Surname = "Petigriu",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "4206666666666"
};
GroupModel groupModel = new GroupModel
{
Id = Guid.NewGuid(),
Name = "Yzomandias",
Description = "Skupina pro organizaci vystoupení spolu s umělcem PTK",
};
GroupMemberModel groupMemberModel = new GroupMemberModel
{
Id = Guid.NewGuid(),
User = userModel,
Group = groupModel,
Permission = PermissionEnum.Moderator
};
ContributionModel contributionModel = new ContributionModel
{
Id = Guid.NewGuid(),
User = userModel,
Group = groupModel,
Message = "Přijede muzika sraz v 9 večer Severka",
Title = "Přijede muzika",
Time = DateTime.MaxValue
};
ReactionModel reactionModel = new ReactionModel
{
Id = Guid.NewGuid(),
User = userModel,
Contribution = contributionModel,
ReactionType = ReactionTypeEnum.Booze
};
reactionRepository.Insert(reactionModel);
var reactionRepositoryResponse = reactionRepository.getReactionByUserId(userModel.Id);
Assert.NotNull(reactionRepositoryResponse);
}
public object GetMembers([FromQuery] TokenQueryModel tokenData, [FromQuery] GroupIdentityModel groupIdentity)
{
var token = tokenRepository.ValidateToken(tokenData.Token);
var members = groupRepository.SelectMembers(groupIdentity.GroupId);
var result = new List <GroupMemberModel>();
foreach (var member in members)
{
result.Add(GroupMemberModel.Create(member));
}
return(result);
}
private void addUserClicked(object sender, RoutedEventArgs e)
{
Button button = e.Source as Button;
if (button == null)
{
return;
}
GroupMemberModel user = button.DataContext as GroupMemberModel;
if (user == null)
{
return;
}
model.AddMember(user);
}
public async Task <IActionResult> GetGroupMembers(string id)
{
try
{
if (string.IsNullOrEmpty(id) || string.IsNullOrWhiteSpace(id))
{
_logger.LogError("GroupMembersController-GetGroupMembers: Id cannot be empty");
return(BadRequest());
}
var groupMemberModel = new GroupMemberModel
{
GroupId = id
};
_logger.LogInfo($"GroupMembersController-GetGroupMembers: [Started] to get member detail for group id {id} from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupMembersController-GetGroupMembers: Unable to create object for graph client");
return(NotFound());
}
GroupService groupService = new GroupService(_logger, client);
groupMemberModel = await groupService.GetGroupMemberAsync(id);
_logger.LogInfo($"GroupMembersController-GetGroup: [Completed] to getting member detail for group id {id} from Azure AD B2C");
return(Ok(groupMemberModel));
}
catch (ServiceException ex)
{
_logger.LogError("GroupMembersController-GetGroup: Exception occured....");
_logger.LogError(ex);
if (ex.StatusCode == HttpStatusCode.BadRequest)
{
return(BadRequest());
}
else
{
return(NotFound());
}
}
}
public async Task <IActionResult> AddMember(string userId, int?groupId)
{
if (userId == null || groupId == null)
{
return(NotFound());
}
var groupMember = new GroupMemberModel
{
ApplicationUserId = userId,
GroupId = (int)groupId,
JoinDate = DateTime.Now
};
_context.GroupMembers.Add(groupMember);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Create), new { groupId }));
}
public void Save()
{
Model.Id = Guid.NewGuid();
GroupMemberModel groupMember = new GroupMemberModel();
groupMember.Id = Guid.NewGuid();
groupMember.Group = Model;
groupMemberRepository.Insert(groupMember);
var groupMemberGet = groupMemberRepository.dbContext.GroupMembers.SingleOrDefault(i => i.Id == groupMember.Id);
groupMemberGet.User = groupMemberRepository.dbContext.Users.SingleOrDefault(i => i.Id == LoggedUserID.userModel.Id);
groupMemberRepository.dbContext.SaveChanges();
mediator.Send(new AddedGroupMessage {
Id = Model.Id
});
Model = null;
}
public async Task <IActionResult> AcceptJoinRequest(int?id)
{
if (id == null)
{
return(NotFound());
}
var request = await _context.JoinGroupRequests
.FirstOrDefaultAsync(s => s.Id == id);
var groupMember = new GroupMemberModel
{
GroupId = request.GroupId,
ApplicationUserId = request.ApplicationUserId,
JoinDate = DateTime.Now
};
_context.GroupMembers.Add(groupMember);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(DeleteJoinRequest), new { id }));
}
public string createGroup(GroupModel group)
{
UserModel user = db.Users.Find(group.owner);
if (user == null)
{
return(null);
}
group.id = group.owner + group.groupName;
group.reqPending = 0;
db.Groups.Add(group);
GroupMemberModel gm = new GroupMemberModel();
gm.id = group.id;
gm.reqStatus = true;
gm.username = group.owner;
db.GroupMembers.Add(gm);
db.SaveChanges();
return(group.id);
}
public async Task <GroupMemberModel> GetGroupMembers(string id)
{
try
{
if (string.IsNullOrEmpty(id) || string.IsNullOrWhiteSpace(id))
{
_logger.LogError("GroupMemberService-GetGroupMembers: Id cannot be empty");
return(null);
}
var groupMemberModel = new GroupMemberModel
{
GroupId = id
};
_logger.LogInfo($"GroupMemberService-GetGroupMembers: [Started] to get member detail for group id {id} from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
if (client == null)
{
_logger.LogError("GroupMemberService-GetGroupMembers: Unable to create object for graph client");
return(null);
}
groupMemberModel = await GetGroupMemberAsync(id);
_logger.LogInfo($"GroupMemberService-GetGroup: [Completed] to getting member detail for group id {id} from Azure AD B2C");
return(groupMemberModel);
}
catch (ServiceException ex)
{
_logger.LogError("GroupMemberService-GetGroup: Exception occured....");
_logger.LogError(ex);
throw ex;
}
}
// GET: Groups/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var group = await _context.Groups.FirstOrDefaultAsync(m => m.Id == id);
if (group == null)
{
return(NotFound());
}
var clients = from c in _context.Clients
where c.GroupId == id
select c;
var employees = from e in _context.Employees
where e.GroupId == id
select e;
var groupLeader = await _context.Employees.FirstOrDefaultAsync(e => e.Id == group.GroupLeaderEmployeeId);
//employees.FirstOrDefaultAsync(e => e.Id == group.GroupLeaderEmployeeId);
//.Where(e => e.Id == group.GroupLeaderEmployeeId);
var groupMembers = new GroupMemberModel
{
Group = group,
Clients = await clients.ToListAsync(),
Employees = await employees.ToListAsync(),
GroupLeader = groupLeader
};
return(View(groupMembers));
}
private void removeUserClicked(object sender, RoutedEventArgs e)
{
Button button = e.Source as Button;
if (button == null)
{
return;
}
GroupMemberModel user = button.DataContext as GroupMemberModel;
if (user == null)
{
return;
}
ConfirmationDialog errorDialog = new ConfirmationDialog();
errorDialog.Owner = this;
errorDialog.Title = "Confirmation Required";
errorDialog.ConfirmationDetails.Message = "Are you sure you want to remove this user?";
if (errorDialog.ShowDialog() == true)
{
model.RemoveMember(user);
}
}
public Boolean addMembers(GroupMemberCreateModel group)
{
/*con.ConnectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=RSSDB;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
* int[] userid = new int[users.Length];
* try
* {
* using (con)
* {
* string command = "";
* SqlCommand cmd = new SqlCommand();
* SqlDataReader rdr;
* cmd.Connection = con;
* SqlParameter gid = new SqlParameter("@gid", id);
* command = "Select id from Group where Id=@gid";
* cmd.CommandText = command;
* cmd.Parameters.Add(gid);
* con.Open();
* rdr = cmd.ExecuteReader();
* if (rdr == null)
* {
* return false;
* }
* command = "Select id from User where username=@uname";
* cmd.CommandText = command;
* for (int i = 0; i < users.Length; i++)
* {
* SqlParameter uname = new SqlParameter("@uname", users[i]);
* cmd.Parameters.Add(uname);
* rdr = cmd.ExecuteReader();
* if (rdr != null)
* {
* userid[i] = (int)rdr["id"];
* rdr.Close();
* }
* else
* {
* return false;
* }
* }
* command = "INSERT INTO Group_Member(Id,userid,reqStatus) VALUES(@gid,@uid,0)";
* cmd.CommandText = command;
* cmd.Parameters.Add(gid);
* SqlParameter uid = new SqlParameter();
* uid.ParameterName = "@uid";
* for (int i = 0; i < users.Length; i++)
* {
* uid.Value = userid[i];
* cmd.Parameters.Add(uid);
* if (cmd.ExecuteNonQuery() <= 0)
* {
* return false;
* }
* }
* con.Close();
* return true;
*
* }
* }
* catch (Exception ex)
* {
* Console.Write("Errors: " + ex.Message);
* return false;
* }*/
//object[] ob = { group.id };
GroupModel g = db.Groups.Find(group.id);
if (g == null)
{
return(false);
}
if (g.owner != group.owner)
{
return(false);
}
List <GroupMemberModel> gms = new List <GroupMemberModel>();
foreach (string uname in group.users)
{
if (db.Users.Find(uname) != null && db.GroupMembers.Find(group.id, uname) == null)
{
GroupMemberModel gm = new GroupMemberModel();
gm.id = group.id;
gm.username = uname;
gm.reqStatus = false;
g.reqPending += 1;
gms.Add(gm);
}
}
if (db.GroupMembers.Find(group.id, group.owner) == null)
{
gms.Add(new GroupMemberModel()
{
id = group.id, reqStatus = true, username = group.owner
});
}
db.GroupMembers.AddRange(gms);
db.Entry <GroupModel>(g).State = EntityState.Modified;
db.SaveChanges();
return(true);
}
public IHttpActionResult GrantAdmin(GroupMemberModel member)
{
MembershipManager.GrantAdminPrivilage(member.Email, member.GroupId, User.Identity.GetUserId());
return(Ok());
}
private async Task <GroupMemberModel> GetGroupMemberAsync(string groupId)
{
GroupMemberModel retVal = null;
try
{
if (string.IsNullOrEmpty(groupId))
{
_logger.LogError("GroupMemberService-GetGroupMemberAsync: Group Id cannot be null");
return(retVal);
}
_logger.LogInfo("GroupMemberService-GetGroupMemberAsync: Starting to get group owner from Azure AD B2C");
var client = GraphClientUtility.GetGraphServiceClient();
retVal = new GroupMemberModel
{
GroupId = groupId
};
var tasks = new Task[]
{
Task.Run(async() => {
Dictionary <string, string> membersList = null;
var users = await client.Users.Request().GetAsync();
if (users != null)
{
membersList = new Dictionary <string, string>();
foreach (var user in users.Where(x => !string.IsNullOrEmpty(x.UserPrincipalName)))
{
try
{
if (!membersList.ContainsKey(user.Id))
{
var value = string.IsNullOrEmpty(user.GivenName + user.Surname) ? user.UserPrincipalName : $"{user.GivenName} {user.Surname}";
membersList.Add(user.Id, value);
}
}
catch (Exception ex)
{
_logger.LogError($"GroupMemberService-GetGroupOwnerMemberAsync: unable to add user in the group owner and member collection for user {user.UserPrincipalName}");
_logger.LogError(ex);
}
}
}
if (membersList != null)
{
retVal.Members = new Dictionary <string, string>();
foreach (var aDict in membersList)
{
retVal.Members.Add(aDict.Key, aDict.Value);
}
}
}),
Task.Run(async() =>
{
List <UserModel> assignedMembers = new List <UserModel>();
var members = await client.Groups[groupId].Members.Request().GetAsync();
if (members != null)
{
foreach (var member in members)
{
try
{
if (!(member is User))
{
continue;
}
UserModel userModel = GraphClientUtility.ConvertGraphUserToUserModel((User)member, _logger);
assignedMembers.Add(userModel);
}
catch (Exception ex)
{
_logger.LogError($"GroupMemberService-GetMembersForGroup: Error adding group owner to the collection for owner {member.Id}");
_logger.LogError(ex);
}
}
}
if (assignedMembers != null)
{
retVal.AssignedMembers = assignedMembers.ToList <UserModel>();
}
})
};
await Task.WhenAll(tasks);
if (retVal != null)
{
if ((retVal.AssignedMembers != null) && (retVal.Members != null))
{
var userIds = retVal.AssignedMembers.Select(x => x.Id).ToList();
if (retVal.Members.Any() && userIds.Any())
{
var keys = retVal.Members.Keys.Where(x => userIds.Contains(x)).ToList();
foreach (var key in keys)
{
retVal.Members.Remove(key);
}
}
}
}
_logger.LogInfo("GroupMemberService-GetGroupMemberAsync: Completed getting the group owner from Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError("GroupMemberService-GetGroupMemberAsync: Exception occured....");
_logger.LogError(ex);
throw ex;
}
return(retVal);
}
private void DeleteUser(object obj)
{
GroupMemberModel groupMember = groupMemberRepository.GetGroupMemberByIDS(LoggedUserID.selectedUserModel.Id, LoggedUserID.selectedUserModel.Id).FirstOrDefault();
groupMemberRepository.Delete(groupMember);
}
public void Load(Guid id)
{
model = repository.GetById(id);
}
public void GetAllUsersOfGroupByGroupId()
{
InMemoryDbContextFactory Db = new InMemoryDbContextFactory();
var dbContext = Db.CreateDbContext();
GroupMemberRepository groupMemberRepository = new GroupMemberRepository(dbContext);
UserRepository userRepository = new UserRepository(dbContext);
GroupModel groupModel1 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "První skupina",
Description = "Popisek1",
};
GroupModel groupModel2 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "Druhá skupina",
Description = "Popisek2",
};
GroupModel groupModel3 = new GroupModel
{
Id = Guid.NewGuid(),
Name = "Třetí skupina",
Description = "Popisek3",
};
UserModel userModel1 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Karel",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
UserModel userModel2 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Pavel",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
UserModel userModel3 = new UserModel
{
Id = Guid.NewGuid(),
Name = "Martin",
Surname = "Vlach",
Email = "*****@*****.**",
Password = "******",
TelephoneNumber = "+420420420420",
};
userRepository.Insert(userModel1);
userRepository.Insert(userModel2);
userRepository.Insert(userModel3);
var userRepositoryResponse1 = userRepository.GetById(userModel1.Id);
var userRepositoryResponse2 = userRepository.GetById(userModel2.Id);
var userRepositoryResponse3 = userRepository.GetById(userModel3.Id);
Assert.NotNull(userRepositoryResponse1);
Assert.NotNull(userRepositoryResponse2);
Assert.NotNull(userRepositoryResponse3);
GroupMemberModel groupMemberModel1 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel1,
User = userModel1,
Permission = PermissionEnum.User
};
GroupMemberModel groupMemberModel2 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel1,
User = userModel2,
Permission = PermissionEnum.User
};
GroupMemberModel groupMemberModel3 = new GroupMemberModel
{
Id = Guid.NewGuid(),
Group = groupModel2,
User = userModel1,
Permission = PermissionEnum.Admin
};
dbContext.DetachAllEntities();
groupMemberRepository.Insert(groupMemberModel1);
groupMemberRepository.Insert(groupMemberModel2);
groupMemberRepository.Insert(groupMemberModel3);
var groupMemberRepositoryResponse1 = groupMemberRepository.GetById(groupMemberModel1.Id);
var groupMemberRepositoryResponse2 = groupMemberRepository.GetById(groupMemberModel2.Id);
var groupMemberRepositoryResponse3 = groupMemberRepository.GetById(groupMemberModel3.Id);
Assert.NotNull(groupMemberRepositoryResponse1);
Assert.NotNull(groupMemberRepositoryResponse2);
Assert.NotNull(groupMemberRepositoryResponse3);
var userRepositoryResponseUsers = userRepository.GetAllUsersOfGroupByGroupId(groupModel1.Id);
Assert.NotNull(userRepositoryResponseUsers);
Assert.Equal(userRepositoryResponseUsers.ElementAt(0).Id, userModel1.Id);
Assert.Equal(userRepositoryResponseUsers.ElementAt(1).Id, userModel2.Id);
Assert.Equal(userRepositoryResponseUsers.Count, 2);
}
public async Task <GroupMemberModel> GetGroupMemberAsync(string groupId)
{
GroupMemberModel retVal = null;
try
{
if (string.IsNullOrEmpty(groupId))
{
_logger.LogError("GroupService-GetGroupMemberAsync: Group Id cannot be null");
return(retVal);
}
_logger.LogInfo("GroupService-GetGroupMemberAsync: Starting to get group owner from Azure AD B2C");
retVal = new GroupMemberModel
{
GroupId = groupId
};
var tasks = new Task[]
{
Task.Run(() => {
var membersList = GetNewGroupDefaultOwnerMember();
if (membersList != null)
{
retVal.Members = new Dictionary <string, string>();
foreach (var aDict in membersList.Result)
{
retVal.Members.Add(aDict.Key, aDict.Value);
}
}
}),
Task.Run(() =>
{
var assignedMembers = GetMembersForGroup(groupId);
if (assignedMembers != null)
{
retVal.AssignedMembers = assignedMembers.Result.ToList <UserModel>();
}
})
};
await Task.WhenAll(tasks);
if (retVal != null)
{
if ((retVal.AssignedMembers != null) && (retVal.Members != null))
{
var userIds = retVal.AssignedMembers.Select(x => x.Id).ToList();
retVal.Members = FilterGroupOwnerMember(userIds, retVal.Members);
}
}
_logger.LogInfo("GroupService-GetGroupMemberAsync: Completed getting the group owner from Azure AD B2C");
}
catch (Exception ex)
{
_logger.LogError("GroupService-GetGroupMemberAsync: Exception occured....");
_logger.LogError(ex);
throw ex;
}
return(retVal);
}
