private void TextBox_LostFocus(object sender, RoutedEventArgs e)
{
AddMemberViewModel model = this.DataContext as AddMemberViewModel;
model.DisplayMode = 0;
model.KeyboardLittle.IsDisplayKeyboard = false;
}
public async Task <IActionResult> AddMember(AddMemberViewModel membersModel)
{
if (ModelState.IsValid)
{
var currManager = await _userManager.FindByNameAsync(User.Identity.Name);
var newUser = await _userManager.FindByEmailAsync(membersModel.NewMember);
var managerUser = new ManagerViewModel()
{
Id = Guid.NewGuid().ToString(), ManagerId = currManager.Id, UserId = newUser.Id
};
if (!_managerAppService.Find(managerUser).Result)
{
await _managerAppService.AddMember(managerUser);
var usersManager = await _managerAppService.GetAll();
var members = new List <IdentityUser>();
foreach (var item in usersManager)
{
if (item.ManagerId == currManager.Id)
{
var user = await _userManager.FindByIdAsync(item.UserId);
members.Add(user);
}
}
return(RedirectToAction("Index", members.ToList()));
}
}
return(View(membersModel));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
AddMemberViewModel member = (AddMemberViewModel)validationContext.ObjectInstance;
if (member._userName == null)
{
return(new ValidationResult("Username is required!"));
}
else if (_userService.isProjectMember(member._userName, member._projectID))
{
return(new ValidationResult("This user is already in this project!"));
}
else if (_userService.isProjectOwner(member._userName, member._projectID))
{
return(new ValidationResult("You are already an owner of this project!"));
}
else if (_userService.userIsInDataBase(member._userName))
{
return(ValidationResult.Success);
}
else
{
return(new ValidationResult("Username does not exist!"));
}
}
public async Task <IActionResult> AddMember()
{
var currManager = await _userManager.FindByNameAsync(User.Identity.Name);
var membersModel = new AddMemberViewModel()
{
ManagerId = currManager.Id,
Email = currManager.Email,
Members = new List <string>(),
NewMember = null
};
foreach (var item in _userManager.Users)
{
var managerVM = new ManagerViewModel()
{
ManagerId = currManager.Id,
UserId = item.Id
};
if (_userManager.IsInRoleAsync(item, "User").Result&& !_managerAppService.Find(managerVM).Result)
{
membersModel.Members.Add(item.Email);
}
}
return(View(membersModel));
}
/// <summary>
/// 添加会员
/// </summary>
/// <returns></returns>
public ActionResult AddMember()
{
AddMemberViewModel model = new AddMemberViewModel();
model.regintable = bll.GetReginTableListModel(1);
return(View(model));
}
public AddMemberViewModel GetMembers(int groupId, int userId)
{
if (!_groupMemberRepository.IsInGroup(groupId, userId))
{
throw new ArgumentException("Wrong groupId or group does not belong to you");
}
var members = _groupMemberRepository.Get(g => g.GroupId == groupId).ToList();
var groupRoles = _roleRepository.Get(r => r.RoleType.Name.Equals("Group")).ToList();
AddMemberViewModel viewModel = new AddMemberViewModel();
foreach (var role in groupRoles)
{
viewModel.GroupRoles.Add(role.ToGroupRole());
}
foreach (var member in members)
{
viewModel.Members.Add(member.ToMemberViewModel());
}
viewModel.GroupId = groupId;
viewModel.GroupTitle = members.First().Group.Title;
viewModel.IsOwner = IsGroupOwner(groupId, userId);
return(viewModel);
}
public ActionResult AddMemberByName(Guid bandId)
{
var band = GetBandById(bandId);
var vm = new AddMemberViewModel {
Band = band
};
return(View(vm));
}
//for testing purposes
public ActionResult NewMember2()
{
IAdminService adminService = new AdminService();
ViewBag.Memberships = adminService.GetMemberships(null).Where(x => x.IsActive).ToList();
var m = new AddMemberViewModel();
return(View(m));
}
public AddMemberView(MemberModel member = null)
{
InitializeComponent();
DataContext = ViewModel = new AddMemberViewModel(member);
ViewModel.PropertyChanged += ViewModelOnPropertyChanged;
Owner = Application.Current.MainWindow;
Loaded += OnAddMemberViewLoaded;
}
public List <GymMember> CheckIfMemberIdExist(AddMemberViewModel membersToCheck)
{
try
{
IUserRepository userRepository = new UserRepository();
return(userRepository.CheckIfMemberIdExist(membersToCheck).ToList());
}
catch (Exception)
{
throw;
}
}
public async Task <ActionResult> AddMember(AddMemberViewModel project)
{
string token = Request.Headers["Authorization"];
var userID = JWTExtensions.GetDecodeTokenByProperty(token, "nameid").ToInt();
project.UserID = userID;
var model = await _projectService.AddMember(project);
await _hubContext.Clients.All.SendAsync("ReceiveMessage", model.Item2, "message");
return(Ok(model.Item1));
}
public ActionResult AddProjectMember(int?projectID)
{
if (_projectService.projectExist(projectID))
{
if (_userService.isProjectOwner(User.Identity.Name, projectID.Value))
{
AddMemberViewModel model = new AddMemberViewModel();
model._projectID = projectID.Value;
return(View(model));
}
}
return(HttpNotFound());
}
public async Task <ActionResult> AddMember(
string id,
AddMemberViewModel model)
{
ApplicationUser au = db.Users.Find(HttpContext.User.Identity.GetUserId());
Project project = await db.Projects.FindAsync(int.Parse(id));
if (!(au.OrganizerInProjects.Contains(project) || au.MemberInProjects.Contains(project) || UserManager.IsInRole(au.Id, "Administrator")))
{
TempData["Toast"] = new Toast
{
Title = "Project",
Body = "Access unauthorized!",
Type = ToastType.Danger
};
return(RedirectToAction("Index", "Home"));
}
if (ModelState.IsValid)
{
foreach (string username in model.AddedMembers)
{
ApplicationUser user = await UserManager.FindByNameAsync(username);
user = db.Users.Find(user.Id);
if (user != null)
{
//db.ProjectMembers.Add(new ProjectMembers {
// ProjectId = t.ProjectId,
// ApplicationUserId = user.Id });
project.Members.Add(user);
}
}
await db.SaveChangesAsync();
TempData["Toast"] = new Toast {
Title = "Project",
Body = "Member successfully added!",
Type = ToastType.Success
};
return(RedirectToAction("Details", new { id = project.ProjectId }));
}
TempData["Toast"] = new Toast
{
Title = "Project",
Body = "Member add unsuccessful!",
Type = ToastType.Danger
};
return(View(model));
}
private void TextBox_KeyDown(object sender, KeyEventArgs e)
{
TextBox tb = sender as TextBox;
tb.Text = tb.Text.Trim();
AddMemberViewModel model = this.DataContext as AddMemberViewModel;
//model.ChangePrices();
if (tb.CaretIndex != tb.Text.Length)
{
tb.CaretIndex = tb.Text.Length;
}
}
public ActionResult ManageMember(AddMemberViewModel member)
{
if (ModelState.IsValid)
{
User existUser = userService.findByUsername(member.Username);
if (existUser != null)
{
ModelState.AddModelError("Username", "Tên người dùng này đã được sử dụng");
}
else
{
var curUser = userService.findById(int.Parse(User.Identity.GetUserId()));
User newUser = new User();
newUser.Creator = curUser.Id;
newUser.Fullname = member.Fullname;
newUser.Username = curUser.House.HouseName + "_" + member.Username;
newUser.Password = member.Password;
newUser.Gender = member.Gender;
newUser.ProfileImage = member.ImageURL;
newUser.RoleId = SLIM_CONFIG.Role_RESIDENT;
newUser.HouseId = curUser.HouseId;
newUser.Status = SLIM_CONFIG.USER_APPROVE_WAITING;
newUser.DateOfBirth = member.DateOfBirth;
newUser.CreateDate = DateTime.Now;
newUser.LastModified = DateTime.Now;
userService.addUser(newUser);
}
}
else
{
ViewBag.adding = true;
}
var currentUser = User.Identity;
int userId;
bool isValidID = int.TryParse(currentUser.GetUserId(), out userId);
if (!isValidID)
{
return(View("error"));
}
User user = userService.findById(userId);
List <User> members = userService.findByHouseId(user.Id);
ViewBag.currentHouse = user.House;
ViewBag.members = members;
return(View());
//pendingMemberService.addMemberRequest(member);
}
public ActionResult AddProjectMember(AddMemberViewModel model)
{
if (!ModelState.IsValid)
{
AddMemberViewModel viewModel = new AddMemberViewModel();
viewModel._userName = model._userName;
viewModel._projectID = model._projectID;
return(View("AddProjectMember", viewModel));
}
else
{
_userService.addProjectMember(model);
ProjectViewModel model2 = _projectService.getProjectByProjectId(User.Identity.Name, model._projectID);
return(View("DisplayProject", model2));
}
}
private void TextBox_GotFocus(object sender, RoutedEventArgs e)
{
AddMemberViewModel model = this.DataContext as AddMemberViewModel;
model.DisplayMode = 1;
TextBox tb = sender as TextBox;
if (null != tb)
{
tb.CaretIndex = tb.Text.Length;
}
model.KeyboardLittle.IsDisplayKeyboard = true;
}
public int AddMembers(AddMemberViewModel members)
{
try
{
IUserRepository userRepository = new UserRepository();
var success = userRepository.CreateMembers(members);
if (success > 0)
{
SaveAccessLog(new AccessLog("CREATE MEMBER", string.Format("created member(s) id {0} ", success), "MEMBER", success));
}
return(success);
}
catch (Exception)
{
throw;
}
}
public void TestAddProjectMember()
{
// Arrange:
AddMemberViewModel model = new AddMemberViewModel
{
_projectID = 1,
_projectName = "pro1",
_userName = "******"
};
// Act:
bool check1 = _userService.isProjectMember(model._userName, model._projectID);
_userService.addProjectMember(model);
bool check2 = _userService.isProjectMember(model._userName, model._projectID);
// Assert:
Assert.AreNotEqual(check1, check2);
}
public ActionResult AddingMembers(string direction, Guid groupId)
{
try {
AddMemberViewModel model = new AddMemberViewModel()
{
GroupId = groupId,
};
var list = _groupService.GetAllDirections();
list.Add("Все направления");
model.Directions = list;
model.SelectedDirection = direction;
return(View(model));
}
catch (Exception e)
{
return(View());
}
}
/// <summary>
/// Gets project by project ID and user by username if both are valid adds a
/// new 'ProjectMember' to Db.
/// </summary>
/// <param name="model">'AddMemberViewModel'</param>
public void addProjectMember(AddMemberViewModel model)
{
ProjectMember newProjectMember = new ProjectMember();
// Select project from db that corresponds to user selected/entered project
var project = (from p in _db._projects
where p.ID == model._projectID
select p).SingleOrDefault();
// Select username from db that corresponds to user selected/entered username
var user = (from u in _db.Users
where u.UserName == model._userName
select u).SingleOrDefault();
if (project != null && user != null)
{
newProjectMember._projectID = project.ID;
newProjectMember._userName = user.UserName;
_db._projectMembers.Add(newProjectMember);
_db.SaveChanges();
}
}
public ActionResult AddMember(int id)
{
var teamInDb = context.Teams.SingleOrDefault(m => m.Id == id);
if (teamInDb == null)
{
return(HttpNotFound());
}
List <ApplicationUser> usersInDb = context.Users.ToList();
List <ApplicationUser> usersForViewModel = new List <ApplicationUser>();
List <ApplicationUser> usersAlreadyMembers = context.Members.Where(m => m.TeamId == teamInDb.Id).Select(m => m.Member).ToList();
var index = usersInDb.FindIndex(m => m.UserName == "*****@*****.**");
usersInDb.RemoveAt(index);
index = usersInDb.FindIndex(m => m.Id == teamInDb.TeamLeaderId);
usersInDb.RemoveAt(index);
foreach (var user in usersInDb)
{
if (usersAlreadyMembers.FindIndex(p => p.Id == user.Id) == -1)
{
usersForViewModel.Add(user);
}
}
var viewModel = new AddMemberViewModel
{
Member = new MemberModels
{
Id = 0,
TeamId = teamInDb.Id,
Team = teamInDb
},
Users = usersForViewModel
};
return(View("AddMember", viewModel));
}
public async Task <IActionResult> AddMember(AddMemberViewModel viewModel, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var account = await AccountProvider.GetAccountForCurrentUser(cancellationToken);
var group = await GetGroup(viewModel.GroupId, cancellationToken);
if (group == null)
{
ModelState.AddModelError(nameof(viewModel.GroupId), "Group does not exist");
return(View(viewModel));
}
if (!group.IsOwner(account))
{
ModelState.AddModelError(String.Empty, "Only group admin can delete it's members.");
return(View(viewModel));
}
var newMember = await MailAppDbContext.Accounts.SingleOrDefaultAsync(x => x.Nick == viewModel.AccountNick, cancellationToken);
if (newMember == null)
{
ModelState.AddModelError(nameof(viewModel.AccountNick), "There is no Account with such nick.");
return(View(viewModel));
}
group.AddAccount(newMember);
await MailAppDbContext.SaveChangesAsync(cancellationToken);
return(RedirectToAction(nameof(Details), new { groupId = viewModel.GroupId }));
}
public async Task <Tuple <bool, string> > AddMember(AddMemberViewModel addMember)
{
try
{
var listUsers = new List <int>();
if (addMember.Users.Length > 0)
{
//get old member list
var oldMembers = await _teamMemberRepository.FindAll().Where(x => x.ProjectID == addMember.ProjectID).Select(x => x.UserID).ToArrayAsync();
//new member list from client
var newMembers = addMember.Users;
//get value of old members list without value in new member list
var withOutInOldMembers = newMembers.Except(oldMembers).ToArray();
if (withOutInOldMembers.Length > 0)
{
var members = new List <TeamMember>();
foreach (var pic in withOutInOldMembers)
{
members.Add(new TeamMember
{
UserID = pic,
ProjectID = addMember.ProjectID
});
}
await _teamMemberRepository.AddMultipleAsync(members);
var project = await _projectRepository.FindByIdAsync(addMember.ProjectID);
var user = await _userRepository.FindByIdAsync(addMember.UserID);
string urlResult = $"/project-detail/{project.ID}";
var message = $"The {user.Username.ToTitleCase()} account has assigned you as member of {project.Name} project";
var notify = new CreateNotifyParams
{
AlertType = AlertType.Member,
Message = message,
Users = withOutInOldMembers.Distinct().ToList(),
URL = urlResult,
UserID = addMember.UserID
};
var addNotify = _mapper.Map <Notification>(notify);
await _notificationRepository.AddAsync(addNotify);
listUsers.AddRange(withOutInOldMembers);
}
else
{
//Day la userID se bi xoa
var withOutInNewMembers = oldMembers.Where(x => !newMembers.Contains(x)).ToArray();
var listDeleteMembers = await _teamMemberRepository.FindAll().Where(x => withOutInNewMembers.Contains(x.UserID) && x.ProjectID.Equals(addMember.ProjectID)).ToListAsync();
_teamMemberRepository.RemoveMultiple(listDeleteMembers);
}
}
await _unitOfWork.Commit();
return(Tuple.Create(true, string.Join(",", listUsers.Distinct().ToArray())));
}
catch (Exception)
{
return(Tuple.Create(false, ""));
}
}
public ActionResult NewMember(AddMemberViewModel members)
{
try
{
List <string> errors = new List <string>();
var i = 1;
var street = members.GymMembers[0].StreetAddress;
var town = members.GymMembers[0].Town;
var homephone = members.GymMembers[0].HomePhone;
if (String.IsNullOrWhiteSpace(members.MembershipCode))
{
errors.Add("Select a <b>Membership Code</b>");
}
if (String.IsNullOrWhiteSpace(members.Club))
{
errors.Add("Select a <b>Club</b>");
}
//fill ini i
foreach (var m in members.GymMembers)
{
if (i <= members.NumMembers)
{
if (!string.IsNullOrWhiteSpace(m.FirstnameLastnameForm))
{
if (m.FirstnameLastnameForm.Contains(","))
{
var names = m.FirstnameLastnameForm.Split(',');
if (names.Length > 1)
{
m.Firstname = names[0];
StringBuilder lastname = new StringBuilder();
var l = 0;
foreach (var n in names)
{
if (l > 0)
{
lastname.AppendFormat("{0} ", n);
}
l++;
}
lastname.Length--;
m.Lastname = lastname.ToString();
}
else
{
m.Firstname = m.FirstnameLastnameForm;
}
}
else
{
var names = m.FirstnameLastnameForm.Split(' ');
if (names.Length > 1)
{
m.Firstname = names[0];
StringBuilder lastname = new StringBuilder();
var l = 0;
foreach (var n in names)
{
if (l > 0)
{
lastname.AppendFormat("{0} ", n);
}
l++;
}
lastname.Length--;
m.Lastname = lastname.ToString();
}
else
{
m.Firstname = m.FirstnameLastnameForm;
}
}
}
if (m.UseSameAddressForm)
{
m.StreetAddress = street;
m.Town = town;
m.HomePhone = homephone;
}
//adding common fields
m.HowYouHeardAboutUs = members.HowYouHeardForm;
m.Membership.MembershipCode = members.MembershipCode;
m.Club = members.Club;
//validation
if (String.IsNullOrWhiteSpace(m.Title))
{
errors.Add(string.Format("Select a <b>Title</b> for member <b>#{0}</b>", i));
}
if (String.IsNullOrWhiteSpace(m.Firstname))
{
errors.Add(string.Format("Enter a <b>Firstname</b> for member <b>#{0}</b>", i));
}
if (String.IsNullOrWhiteSpace(m.Lastname))
{
errors.Add(string.Format("Enter a <b>Lastname</b> for member <b>#{0}</b>", i));
}
if (String.IsNullOrWhiteSpace(m.Gender))
{
errors.Add(string.Format("Enter a <b>Gender</b> for member <b>#{0}</b>", i));
}
if (String.IsNullOrWhiteSpace(m.StreetAddress))
{
errors.Add(string.Format("Enter a <b>Street Address</b> for member <b>#{0}</b>", i));
}
if (String.IsNullOrWhiteSpace(m.Town))
{
errors.Add(string.Format("Enter a <b>Town</b> for member <b>#{0}</b>", i));
}
if (m.Age > 100)
{
errors.Add(string.Format("Enter a <b>Date Of Birth</b> for member <b>#{0}</b>", i));
}
var verifyContact = string.Concat(m.EmailAddress, m.HomePhone, m.OfficePhone, m.MobilePhone);
if (string.IsNullOrWhiteSpace(verifyContact))
{
errors.Add(string.Format("Enter at least an <b>email</b> or <b>phone contact</b> for member <b>#{0}</b>", i));
}
if (members.IsCustom && m.CustomMonthlyFee <= 0)
{
errors.Add(string.Format("Enter a <b>Custom Fee (Monthly)</b> for member <b>#{0}</b>", i));
}
i++;
} //if
} //foreach
if (members.GymMembers.Sum(x => x.MemberId) > 0)
{
IUserService userservice = new UserService();
var memberExist = userservice.CheckIfMemberIdExist(members);
if (memberExist.Count > 0)
{
foreach (var m in memberExist)
{
errors.Add(string.Format("Member Id <b>{0}</b> exists already and is assigned to <b>{1}></b> ", m.MemberId, m.FullnameFromFirstAndLastName));
}
}
}
if (errors.Count > 0)
{
IAdminService adminService = new AdminService();
ViewBag.Memberships = adminService.GetMemberships(null).Where(x => x.IsActive).ToList();
members.ValidationErrors = errors;
return(View(members));
}
IUserService userService = new UserService();
var id = userService.AddMembers(members);
if (members.MembershipCode == "FREE")
{
return(RedirectToAction("Member", new { id = id }));
}
return(RedirectToAction("Transaction", new { id = id }));
}
catch (Exception e)
{
log.Error("[NewMember] - Exception Caught" + e.ToString());
TempData["errorLog"] = new ErrorLog(e);
return(RedirectToAction("Error", "Home"));
}
}
