internal GroupMemberViewModel Delete(int id)
{
GroupMemberViewModel exists = GetById(id);
_repo.Delete(id);
return(exists);
}
public async Task <IActionResult> AddGroupMember([FromBody] GroupMemberViewModel newMember)
{
if (ModelState.IsValid)
{
bool groupAdminHasPermission = await this.CheckGroupAdminPermission("users.managegroup");
var isGroupAdmin = groupAdminHasPermission && await this._unitOfWork.GroupMembers.IsGroupAdminAsync(this.User.Identity.Name, newMember.Group);
var isSuperAdmin = (await _authorizationService.AuthorizeAsync(this.User, Authorization.Policies.ManageAllGroupsPolicy)).Succeeded;
if (isGroupAdmin || isSuperAdmin)
{
GroupMember newGMember = Mapper.Map <GroupMember>(newMember);
var result = this._unitOfWork.UserGroups.AddUserAsync(newGMember);
if (result.Item1)
{
await this._unitOfWork.SaveChangesAsync();
return(new OkResult());
}
else
{
AddErrors(result.Item2);
}
}
else
{
return(new ChallengeResult());
}
}
return(BadRequest(ModelState));
}
public static List <GroupMemberViewModel> BuildGroupMemberViewListFromGroupMemberList(ApplicationDbContext db, List <GroupMember> groupMemberList)
{
List <GroupMemberViewModel> list = new List <GroupMemberViewModel>();
foreach (GroupMember member in groupMemberList)
{
Organisation organisaion = OrganisationHelpers.GetOrganisation(db, member.OrganisationId);
AppUser addedBy = AppUserHelpers.GetAppUser(db, member.AddedBy);
AppUser recordChangedBy = AppUserHelpers.GetAppUser(db, member.RecordChangeBy);
GroupMemberViewModel item = new GroupMemberViewModel()
{
GroupMemberId = member.GroupMemberId,
GroupId = member.GroupId,
OrganisationDetails = organisaion,
AddedBy = addedBy,
AddedDateTime = member.AddedDateTime,
Status = member.Status,
RecordChange = member.RecordChange,
RecordChangeOn = member.RecordChangeOn,
RecordChangeBy = recordChangedBy
};
list.Add(item);
}
return(list);
}
public ActionResult ChangeMemberRole(GroupMemberViewModel viewModel)
{
viewModel.CurrentUserId = User.Identity.GetUserId <int>();
_groupService.ChangeMemberRole(viewModel);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
public IActionResult Update(int id, [FromBody] GroupMemberViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != viewModel.Id)
{
return(BadRequest());
}
try
{
var orginalGroupMember = _groupMemberService.Find(id);
if (orginalGroupMember == null)
{
return(NotFound());
}
orginalGroupMember = _mapper.Map(viewModel, orginalGroupMember);
_groupMemberService.Update(orginalGroupMember);
_unitOfWork.Commit();
return(NoContent());
}
catch
{
return(StatusCode(500));
}
}
public static void SaveorUpdateGroupMember(GroupMemberViewModel member, long groupid)
{
var db = new SQLiteConnection(CommonConstant.DBPath);
try
{
var group = GetGroupMemeberByID(groupid, member.MemberId);
if (group == null)
{
var groupmember = new GroupMember();
groupmember.GroupId = groupid;
groupmember.GroupMemberId = member.MemberId;
groupmember.MemberName = member.MemberName;
groupmember.UserId = CommonHelper.GetUserId();
db.Insert(groupmember);
}
else
{
group.GroupId = groupid;
group.GroupMemberId = member.MemberId;
group.MemberName = member.MemberName;
group.UserId = CommonHelper.GetUserId();
db.Update(group);
}
db.Commit();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, ex);
}
db.Close();
}
public static GroupMember ToEntity(this GroupMemberViewModel viewModel)
{
return(new GroupMember()
{
UserId = viewModel.UserId,
GroupId = viewModel.GroupId,
RoleId = viewModel.RoleId
});
}
public ViewResult Members(int id)
{
var members = groupUserService.GetMembersOfGroup(id);
GroupMemberViewModel gmvm = new GroupMemberViewModel()
{
GroupId = id, Group = groupService.GetGroup(id), Users = members
};
return(View(gmvm));
}
internal GroupMemberViewModel GetById(int Id)
{
GroupMemberViewModel exists = _repo.GetById(Id);
if (exists == null)
{
throw new System.Exception("Invalid GroupMember");
}
return(exists);
}
public ActionResult AddMember(GroupMemberViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
viewModel.CurrentUserId = User.Identity.GetUserId <int>();
_groupService.AddMember(viewModel);
return(RedirectToAction("Members", new { id = viewModel.GroupId }));
}
private async void PostGroupData()
{
try
{
if (groupmodel != null && ContactList.Count > 0)
{
List <GroupMemberViewModel> ListGroupMemberViewModel = new List <GroupMemberViewModel>();
for (int i = 0; i < ContactList.Count; i++)
{
if (ContactList[i].isSelected())
{
var _objGroupMemberViewModel = new GroupMemberViewModel
{
MemberId = ContactList[i].ContactId
};
ListGroupMemberViewModel.Add(_objGroupMemberViewModel);
}
}
var _objGroupRequestModel = new GroupRequestViewModel
{
Name = groupmodel.Name,
Description = groupmodel.Description,
InterestId = groupmodel.InterestId,
MemberCount = ListGroupMemberViewModel.Count(),
Visibility = 1,
IsPrivate = groupmodel.IsPrivate,
GroupType = groupmodel.GroupType,
Members = ListGroupMemberViewModel,
UserId = CommonHelper.GetUserId(),
PictureUrl = groupmodel.PictureUrl
};
var result = await new GroupChatService().CreateGroup(_objGroupRequestModel);
if (result.Status == 1)
{
var modelGroup = JsonConvert.DeserializeObject <GroupResponseViewModel>(result.Response.ToString());
await _objChatSignalRService.GroupCreate(modelGroup);
GroupRepository.SaveGroupCreated(modelGroup);
foreach (var member in modelGroup.Members)
{
GroupRepository.SaveorUpdateGroupMember(member, modelGroup.GroupId);
}
StartActivity(typeof(MainActivity));
}
}
}
catch (System.Exception ex)
{
Crashes.TrackError(ex);
}
}
public void AddMember_RejectsWhenNotOwner()
{
// Arrange
var mockGroupMember = new Mock <IGroupMemberRepository>();
IGroupService groupService = new GroupService(null, null, null, mockGroupMember.Object, null);
mockGroupMember.Setup(m => m.GetRole(0, 0)).Returns(RoleNames.ROLE_PARTICIPANT);
var viewModel = new GroupMemberViewModel();
// Act
groupService.AddMember(viewModel);
}
public void AddMember_RejectsWhenAlreadyInGroup()
{
// Arrange
var mockGroupMember = new Mock <IGroupMemberRepository>();
IGroupService groupService = new GroupService(null, null, null, mockGroupMember.Object, null);
mockGroupMember.Setup(m => m.GetRole(0, 0)).Returns(RoleNames.ROLE_OWNER);
mockGroupMember.Setup(m => m.IsInGroup(0, 0)).Returns(true);
var viewModel = new GroupMemberViewModel();
// Act
groupService.AddMember(viewModel);
}
public GroupMemberViewModel AddMemberToGroup(GroupMemberViewModel groupMember)
{
var member = Services.MemberService.GetById(groupMember.MemberId);
var structuralGroup = ApplicationContext.DatabaseContext.Database.Query <StructuralGroup>("SELECT * FROM StructuralGroup WHERE Id = " + groupMember.StructuralGroupId).FirstOrDefault(); //TODO: Move this to a common domain service
if (member == null || structuralGroup == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
MemberHelper.AddMemberToGroup(ApplicationContext.DatabaseContext.Database, groupMember.MemberId, groupMember.StructuralGroupId);
return(new GroupMemberViewModel(new MemberViewModel(member), StructuralGroupViewModel.FromModel(structuralGroup)));
}
public void AddMember_AddsWhenAuthorized()
{
// Arrange
var mockGroupMember = new Mock <IGroupMemberRepository>();
IGroupService groupService = new GroupService(null, null, null, mockGroupMember.Object, null);
mockGroupMember.Setup(m => m.GetRole(0, 0)).Returns(RoleNames.ROLE_OWNER);
mockGroupMember.Setup(m => m.IsInGroup(0, 0)).Returns(false);
var viewModel = new GroupMemberViewModel();
// Act
groupService.AddMember(viewModel);
// Assert
mockGroupMember.Verify(gm => gm.AddUserToGroup(It.IsAny <GroupMember>()));
}
private async Task <List <GroupViewModel> > GetAllGroups(string userId)
{
List <GroupViewModel> groupList = new List <GroupViewModel>();
List <GroupMemberViewModel> groupMembers = new List <GroupMemberViewModel>();
var groups = await groupLogic.GetAllGroups(userId);
if (groups.Count > 0)
{
foreach (var g in groups)
{
if (g.Members != null)
{
foreach (var gMember in g.Members)
{
GroupMemberViewModel currentMember = new GroupMemberViewModel
{
Id = gMember.Id,
UserId = gMember.UserId
};
if (g.Id == gMember.GroupId)
{
groupMembers.Add(currentMember);
}
}
GroupViewModel currentGroup = new GroupViewModel
{
Id = g.Id,
GroupTitle = g.GroupTitle,
OwnerId = g.OwnerId,
MemberIds = groupMembers
};
groupList.Add(currentGroup);
}
else
{
GroupViewModel currentGroup = new GroupViewModel
{
Id = g.Id,
GroupTitle = g.GroupTitle,
OwnerId = g.OwnerId,
};
groupList.Add(currentGroup);
}
}
}
return(groupList);
}
public void ChangeMemberRole(GroupMemberViewModel viewModel)
{
string userRole = _groupMemberRepository.GetRole(viewModel.GroupId, viewModel.CurrentUserId);
if (userRole.Equals(RoleNames.ROLE_OWNER) &&
_groupMemberRepository.IsInGroup(viewModel.GroupId, viewModel.UserId))
{
var groupMember = _groupMemberRepository.Get(u => u.GroupId == viewModel.GroupId && u.UserId == viewModel.UserId).Single();
groupMember.RoleId = viewModel.RoleId;
_groupMemberRepository.Update(groupMember);
}
else
{
throw new ArgumentException("User does not belong to this group");
}
}
public void AddMember(GroupMemberViewModel viewModel)
{
string userRole = _groupMemberRepository.GetRole(viewModel.GroupId, viewModel.CurrentUserId);
if (userRole.Equals(RoleNames.ROLE_OWNER) &&
!_groupMemberRepository.IsInGroup(viewModel.GroupId, viewModel.UserId))
{
var entity = viewModel.ToEntity();
entity.JoinedAt = DateTime.Now;
_groupMemberRepository.AddUserToGroup(entity);
}
else
{
throw new ArgumentException("User is already in this group.");
}
}
public IActionResult Create(int?groupId)
{
ViewData["GroupId"] = groupId;
var users = _context.ApplicationUser.ToList();
var members = _context.GroupMembers.Where(s => s.GroupId == groupId).ToList();
foreach (var member in members)
{
users.Remove(member.User);
}
var groupMemberViewModel = new GroupMemberViewModel
{
Users = users,
Members = members
};
return(View(groupMemberViewModel));
}
public IActionResult Create([FromBody] GroupMemberViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
GroupMember groupMember = _mapper.Map <GroupMemberViewModel, GroupMember>(viewModel);
_groupMemberService.Add(groupMember);
_unitOfWork.Commit();
return(CreatedAtRoute("find", new { id = groupMember.Id }, groupMember));
}
catch
{
return(StatusCode(500));
}
}
/// <summary>
/// Gets all members of a group
/// </summary>
/// <param name="groupId">group id</param>
/// <returns></returns>
private async Task <List <GroupMemberViewModel> > GetAllMembersOfGroup(int groupId)
{
List <GroupMemberViewModel> groupMemberList = new List <GroupMemberViewModel>();
var members = await groupLogic.GetAllMembersOfGroup(groupId);
if (members.Count > 0)
{
foreach (var m in members)
{
GroupMemberViewModel currentMember = new GroupMemberViewModel
{
Id = m.Id,
UserId = m.UserId
};
groupMemberList.Add(currentMember);
}
}
return(groupMemberList);
}
public async Task <IActionResult> UpdateGroupMember([FromBody] GroupMemberViewModel member)
{
GroupMember gMember = Mapper.Map <GroupMember>(member);
var user = await this._accountManager.GetUserByIdAsync(member.User.Id);
this._unitOfWork.GroupMembers.Update(gMember);
if (gMember.GroupAdmin)
{
await this._userManager.AddToRoleAsync((TraisiUser)user, TraisiRoles.GroupAdministrator);
}
else
{
await this._userManager.RemoveFromRoleAsync((TraisiUser)user, TraisiRoles.GroupAdministrator);
}
await this._unitOfWork.SaveChangesAsync();
return(new OkResult());
}
public IActionResult Post([FromBody] GroupMemberViewModel groupMemberViewModel)
{
try
{
var group = _repository.GetGroupById(groupMemberViewModel.GroupId);
if (group == null)
{
return(BadRequest($"Group does not exist. [id={groupMemberViewModel.GroupId}]"));
}
var user = _repository.GetUser(groupMemberViewModel.Member.UserName);
if (user == null)
{
return(BadRequest($"User not found. [user={groupMemberViewModel.Member.UserName}]"));
}
foreach (var member in group.Members)
{
if (member.MemberId.Equals(user.Id))
{
return(BadRequest($"User already in group. [user={user.Id}]"));
}
}
var groupMember = _mapper.Map <GroupMemberViewModel, GroupMember>(groupMemberViewModel);
group.Members.Add(groupMember);
user.Memberships.Add(groupMember);
if (_repository.SaveAll())
{
return(Ok());
}
}
catch (Exception ex)
{
_logger.LogError($"Failed to save group membership changes. [ex={ex}]");
throw;
}
return(BadRequest("Failed to save group membership changes."));
}
public async Task <IActionResult> Put(int id, [FromBody] GroupMemberViewModel APGmembers)
{
if (ModelState.IsValid)
{
try
{
APGmembers _APGmembers = Mapper.Map <APGmembers>(APGmembers);
_unitOfWork.APGmembers.Update(_APGmembers);
await _unitOfWork.SaveChangesAsync();
return(Ok("OK"));
}
catch (Exception ex)
{
return(BadRequest(ex.Data));
}
}
else
{
return(BadRequest(ModelState));
}
}
public IActionResult LoadMoreGroupFollower(string id, int take)
{
if (take >= 0)
{
GroupMemberViewModel groupMemberViewModel = new GroupMemberViewModel();
var currentUserGroup = _context.GroupMember.Join(_context.Users, m => m.MemberId, u => u.Id,
(member, user) => new
{
member.MemberId,
MemberName = user.UserName,
member.IsAdmin,
member.JoinDate,
member.GroupId,
avatarIsExist = user.Avatar != null
}
).Where(m => m.GroupId == id).OrderByDescending(g => g.JoinDate).Skip(take).Take(6);
return(Json(currentUserGroup));
}
return(Json(new List <GroupMember>()));
}
private async Task PostGroupData()
{
try
{
if (groupmodel != null && ContactList.Count > 0)
{
List <GroupMemberViewModel> ListGroupMemberViewModel = new List <GroupMemberViewModel>();
for (int i = 0; i < ContactList.Count; i++)
{
if (ContactList[i].isSelected())
{
var _objGroupMemberViewModel = new GroupMemberViewModel
{
MemberId = ContactList[i].ContactId,
MemberName = ContactList[i].ConatactName
};
ListGroupMemberViewModel.Add(_objGroupMemberViewModel);
}
}
var _objGroupRequestModel = new GroupRequestViewModel
{
Name = groupmodel.Name,
Description = groupmodel.Description,
InterestId = groupmodel.InterestId,
MemberCount = ListGroupMemberViewModel.Count,
Visibility = 1,
IsPrivate = groupmodel.IsPrivate,
GroupType = groupmodel.GroupType,
Members = ListGroupMemberViewModel,
UserId = CommonHelper.GetUserId(),
PictureUrl = groupmodel.PictureUrl
};
BTProgressHUD.Show("Create Group", maskType: ProgressHUD.MaskType.Black);
var result = await new GroupChatService().CreateGroup(_objGroupRequestModel);
if (result.Status == 1)
{
var modelGroup = JsonConvert.DeserializeObject <GroupResponseViewModel>(result.Response.ToString());
await _objChatSignalRService.GroupCreate(modelGroup);
GroupRepository.SaveGroupCreated(modelGroup);
foreach (var member in modelGroup.Members)
{
GroupRepository.SaveorUpdateGroupMember(member, modelGroup.GroupId);
}
BTProgressHUD.Dismiss();
//this.DismissViewController(true, null);
UIStoryboard storyboard = this.Storyboard;
RootViewController viewController = (RootViewController)
storyboard.InstantiateViewController("RootViewController");
this.PresentViewController(viewController, true, null);
}
BTProgressHUD.Dismiss();
}
}
catch (System.Exception ex)
{
BTProgressHUD.Dismiss();
Crashes.TrackError(ex);
}
}