public async Task <IActionResult> RegisterNewMember(string userId, int groupId)
{
try {
GroupMemberProfile memberProfile = await _context.GroupMemberProfiles.FirstOrDefaultAsync(gmp => gmp.Name == GroupMemberProfilesData.Member);
GroupMembers newGroupMember = new GroupMembers
{
GroupId = groupId,
ApplicationUserId = userId,
GroupMemberProfileId = memberProfile.Id
};
_context.GroupMembers.Add(newGroupMember);
await _context.SaveChangesAsync();
string message = $"{EventQueueMessages.NEW_GROUP_MEMBER};{newGroupMember.GroupId};{newGroupMember.ApplicationUserId}";
await _eventQueueService.SendMessageAsync(message);
var dictionay = new Dictionary <string, string>();
dictionay.Add("Queue Message", message);
_telemetryClient.TrackEvent("UserInteraction", dictionay);
} catch (Exception e) {
_logger.LogCritical($"EXCEPCIÓN: {e.Message}");
return(Json(new { success = false }));
}
return(Json(new { success = true }));
}
//拉取或刷新群成员列表
public void refreshMembers(string groupId)
{
//拉取群成员
HttpReqHelper.requestSync(AppConst.WebUrl + "groupMembers?gid=" + groupId, delegate(string membersJson)
{
//先清空
clearMemberSafePost();
// Debug.Print("收到群成员是：" + membersJson);
GroupMembers members = Coding <GroupMembers> .decode(membersJson);
// Debug.Print("群主是：" + members.Master);
GroupMember master = new GroupMember(members.Master, 2);
addMemberSafePost(master);
// Debug.Print("管理是：" + members.Manager);
string[] mans = members.Manager.Split(',');
foreach (var item in mans)
{
if (item != "")
{
// GroupMember manger = new GroupMember(item,1);
// addMemberSafePost(manger);
}
}
// Debug.Print("成员是：" + members.Member);
string[] mems = members.Member.Split(',');
foreach (var item in mems)
{
if (item != "")
{
GroupMember member = new GroupMember(item, 0);
addMemberSafePost(member);
}
}
});
}
private static bool Is_GroupMember(byte machineCode, GroupMembers group)
{
switch (group)
{
case GroupMembers.LLHH:
return(LLHH_Group.Exists(mc => mc == machineCode));
case GroupMembers.YX:
return(YX_Group.Exists(mc => mc == machineCode));
case GroupMembers.OX:
return(OX_Group.Exists(mc => mc == machineCode));
case GroupMembers.YXZ:
return(YXZ_Group.Exists(mc => mc == machineCode));
case GroupMembers.ON:
return(ON_Group.Exists(mc => mc == machineCode));
case GroupMembers.BB:
return(BB_Group.Exists(mc => mc == machineCode));
case GroupMembers.IM:
return(IM_Group.Exists(mc => mc == machineCode));
default:
throw new Exception("Invalid Group of opcode family");
}
}
public int AddMemberToGroup(GroupMembers gm)
{
context.GroupMembers.Add(gm);
int res = context.SaveChanges();
return(res);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Email")] GroupMembers groupMembers)
{
if (id != groupMembers.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(groupMembers);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GroupMembersExists(groupMembers.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(groupMembers));
}
public Group AddGroup(GroupModel model)
{
var group = context.Groups.Add(model.Group);
context.SaveChanges();
foreach (var item in model.MembersId)
{
GroupMembers groupMembers = new GroupMembers()
{
GroupId = model.Group.GroupId,
UserId = item,
};
context.GroupMembers.Add(groupMembers);
context.SaveChanges();
}
var activity = new Activity();
activity.Activitydata = "You Added" + model.Group.Title + "Group";
activity.Date = DateTime.Now.ToString();
activity.UserId = model.Group.CreatorIdId;
context.Activities.Add(activity);
context.SaveChanges();
return(model.Group);
}
private void HandlePartyMembersChanged(object sender, LuaEventArgs args)
{
if (!IsInGroup)
{
Logging.WriteDebug("You left the group");
haveWeChecked = false;
}
else if (IamTheTank || LazyRaiderSettings.Instance.NoTank)
{
Logging.WriteDebug("You are acting as Tank, no leader needed");
haveWeChecked = true;
}
else if (RaFHelper.Leader == null)
{
Log("Joined party -- need to find tank");
haveWeChecked = false;
}
else if (GroupMembers.Contains(RaFHelper.Leader))
{
Logging.WriteDebug("Party Members Changed - Tank still in group");
}
else
{
Log("Tank left group, no tank currently");
RaFHelper.ClearLeader();
haveWeChecked = false;
}
}
public List <TrainingTask> IterateTraining()
{
var ret = new List <TrainingTask>();
var groupMembersRemainingWithNeed = GroupMembers.ToList();
var groupMemberWithNeed = GetFirstGroupMemberWhoHasANeed(groupMembersRemainingWithNeed);
while (groupMemberWithNeed != null)
{
var trainingNeed = groupMemberWithNeed.AspNetUser.CalculateNeed(this);
if (!ret.Any(p => p.SolvesNeed(trainingNeed)))
{
var solutionForNeed = DefineSolutionForNeed(trainingNeed, groupMemberWithNeed);
if (solutionForNeed != null)
{
ret.Add(solutionForNeed);
}
}
groupMembersRemainingWithNeed.Remove(groupMemberWithNeed);
groupMemberWithNeed = GetFirstGroupMemberWhoHasANeed(groupMembersRemainingWithNeed);
}
return(ret);
}
/// <summary>
/// Adds a user to a group.
/// User connects to the group at the next session.
/// </summary>
/// <param name="pUsername">Client's username</param>
public void AddUser(string pUsername)
{
if (!GroupMembers.Contains(pUsername.ToLower()))
{
GroupMembers.Add(pUsername.ToLower());
}
}
public bool AddFriendToGroup(string friendName, string groupName)
{
MessageManager mm = new MessageManager();
bool isExistTheGroupName = mm.IsExistTheGroup(groupName);
if (!isExistTheGroupName)
{
return(false);
}
bool isExistTheFriendName = mm.Exist(friendName);
if (!isExistTheFriendName)
{
return(false);
}
GroupMembers gm = new GroupMembers();
gm.GroupName = groupName;
gm.GroupMember = friendName;
gm.IsPass = true;
try
{
mm.AddFriendToGroup(gm);
}
catch (Exception)
{
throw;
}
return(true);
}
/// <summary>
/// Removes a user from the group.
/// The user stays connected until the next session.
/// </summary>
/// <param name="pUsername">Client's username</param>
public void Remove(string pUsername)
{
if (GroupMembers.Contains(pUsername.ToLower()))
{
GroupMembers.Remove(pUsername.ToLower());
}
}
public int CreateGroup(Groups group)
{
var admin = new GroupMembers();
admin.Gm_Member = group.G_Admin;
var date = DateTime.Now;
group.G_Date = date;
context.Groups.Add(group);
context.SaveChanges();
var gid = context.Groups.Where(g => g.G_Admin == group.G_Admin && g.G_Date == group.G_Date)
.Select(g => g.G_Id).ToList();
admin.GM_GroupId = gid[0];
context.GroupMembers.Add(admin);
//add activity
var act = new Activity();
act.A_DoneBy = group.G_Admin;
act.A_ForGroup = gid[0];
act.A_Description = "Created Group " + group.G_Name;
act.A_Date = date;
context.Activities.Add(act);
int res = context.SaveChanges();
return(gid[0]);
}
public async Task <IEnumerable <(Group Group, bool MayEdit)> > GetAllAsync(ClaimsPrincipal?principal, int countryId)
{
if (principal.IsCountryAdministratorInCountry(countryId))
{
using var dbContext = Factory.CreateDbContext();
var items = await dbContext.Groups.AsNoTracking()
.Where(g => (g.CountryId == countryId) || (g.GroupDomainId > 0 && principal.GroupDomainIds().Contains(g.GroupDomainId.Value)))
.Include(g => g.GroupDomain)
.Include(g => g.Country)
.OrderBy(g => g.FullName)
.ToListAsync();
return(items.Select(i => (i, true)));
}
else
{
using var dbContext = Factory.CreateDbContext();
var items = await dbContext.Groups.AsNoTracking()
.Where(g => (g.GroupDomainId > 0 && principal.GroupDomainIds().Contains(g.GroupDomainId.Value)) || g.GroupMembers.Any(gm => gm.PersonId == principal.PersonId()))
.Include(g => g.GroupDomain)
.Include(g => g.Country)
.OrderBy(g => g.FullName)
.ToListAsync();
return(items.Select(i => (i, i.GroupMembers.Any(gm => (gm.IsDataAdministrator || gm.IsGroupAdministrator) && gm.PersonId == principal.PersonId()))));
}
}
void Start()
{
_members = GetComponent <GroupMembers>();
_attackingPosition = _waypoints.getFinalPoint();
_pathPosition = 0;
updateTarget();
}
void addMemberItem(object state)
{
// Debug.Print("收到群成员是：" + membersJson);
GroupMembers members = Coding <GroupMembers> .decode((string)state);
// Debug.Print("群主是：" + members.Master);
GroupManageMemberItem master = new GroupManageMemberItem(members.Master, 0);
addMemberSafePost(master);
memberAmount++;
// Debug.Print("管理是：" + members.Manager);
string[] mans = members.Manager.Split(',');
foreach (var item in mans)
{
if (item != "")
{
GroupManageMemberItem manager = new GroupManageMemberItem(item, 1);
addMemberSafePost(manager);
memberAmount++;
}
}
string[] mems = members.Member.Split(',');
foreach (var item in mems)
{
if (item != "")
{
GroupManageMemberItem member = new GroupManageMemberItem(item, 2);
addMemberSafePost(member);
memberAmount++;
}
}
}
public void CreateGroup(SmsRequest incomingMessage)
{
bool unknownUser = false;
try
{
UserInfo userInfo = _context.UserInfo.Where(x => x.PhoneNumber == incomingMessage.From).First();
var user = _context.AspNetUsers.Where(x => x.Id == userInfo.UserId).First();
if (userInfo == null)
{
unknownUser = true;
throw new Exception();
}
StringReader reader = new StringReader(incomingMessage.Body);
string line = reader.ReadLine();
List <string> textParts = new List <string>();
while (line != null)
{
textParts.Add(line);
line = reader.ReadLine();
}
List <string> memberNames = new List <string>();
List <string> memberNumbers = new List <string>();
for (int i = 2; i < textParts.Count; i++)
{
if (i % 2 == 0)
{
memberNames.Add(textParts[i]);
}
else
{
memberNumbers.Add(textParts[i]);
}
}
Groups newGroup = new Groups(textParts[1], user.Id);
_context.Groups.Add(newGroup);
_context.SaveChanges();
for (int i = 0; i < memberNames.Count; i++)
{
GroupMembers newMember = new GroupMembers(memberNames[i], newGroup.GroupId, memberNumbers[i]);
_context.GroupMembers.Add(newMember);
_context.SaveChanges();
}
SendSuccessText(incomingMessage, $"You created the group '{textParts[1]}'");
}
catch (Exception)
{
if (unknownUser)
{
SendRegisterText(incomingMessage);
}
}
}
public async Task <IActionResult> AddMemebers([FromBody] GroupMembers grp)
{
await unitofwork.GroupRepository.AddMembers(grp);
await unitofwork.Save();
return(Ok(grp));
}
public Task Remove(string connectionId, string groupName)
{
if (GroupMembers.ContainsKey(groupName))
{
GroupMembers[groupName].Remove(connectionId);
}
return(Groups.Remove(connectionId, groupName));
}
protected async Task FilterUsers()
{
FilteredUsers = (await UserService.Get())
.Where(x => !GroupMembers
.Any(z => x.Id == z.Id))
.Where(x => x.Id != GroupObject.OwnerId)
.ToList();
}
public GroupModel Editgroup(int id, GroupModel groupModel)
{
var oldgroup = context.Groups.ToList().FirstOrDefault(x => x.GroupId == id);
oldgroup.Amount = groupModel.Group.Amount;
oldgroup.CreatorIdId = groupModel.Group.CreatorIdId;
oldgroup.Date = groupModel.Group.Date;
oldgroup.Title = groupModel.Group.Title;
var group = context.Groups.Attach(oldgroup);
group.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
var groupMember = context.GroupMembers.Where(x => x.GroupId == id);
context.GroupMembers.RemoveRange(groupMember);
var groupExpenses = context.GroupsofExpenses.ToList().Where(x => x.GroupId == id);
context.GroupsofExpenses.RemoveRange(groupExpenses);
// foreach (var item in groupExpenses)
// {
// expenserepo.DeleteExpense(item.ExpenseId);
// }
foreach (var item in groupModel.MembersId.ToList())
{
GroupMembers groupMembers = new GroupMembers();
groupMembers.GroupId = oldgroup.GroupId;
groupMembers.UserId = item;
context.GroupMembers.Add(groupMembers);
context.SaveChanges();
}
foreach (var item in groupModel.Expenses.ToList())
{
GroupExpense groupExpense = new GroupExpense()
{
GroupId = oldgroup.GroupId,
ExpenseId = item.ExpenseId,
};
context.GroupsofExpenses.Add(groupExpense);
context.SaveChanges();
}
var activity = new Activity();
activity.Activitydata = "You Edited" + groupModel.Group.Title + "group";
activity.Date = DateTime.Now.ToString();
activity.UserId = groupModel.Group.CreatorIdId;
context.Activities.Add(activity);
context.SaveChanges();
return(groupModel);
}
public int GroupMembers(GroupMembers gm)
{
SqlConnection Conn = new SqlConnection();
try
{
Conn.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["connstr"].ToString();
SqlCommand cmd = new SqlCommand();
cmd.Connection = Conn;
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "InsUpdDelGroupMembers";
SqlParameter gi = new SqlParameter("GroupId", SqlDbType.Int);
gi.Value = gm.GroupId;
cmd.Parameters.Add(gi);
SqlParameter oi = new SqlParameter("OwnerId", SqlDbType.Int);
oi.Value = gm.OwnerId;
cmd.Parameters.Add(oi);
SqlParameter mi = new SqlParameter("MemberId", SqlDbType.Int);
mi.Value = gm.memberId;
cmd.Parameters.Add(mi);
SqlParameter fi = new SqlParameter("FCMID", SqlDbType.VarChar, 50);
fi.Value = gm.FCMID;
cmd.Parameters.Add(fi);
SqlParameter id = new SqlParameter("Id", SqlDbType.Int);
id.Value = gm.Id;
cmd.Parameters.Add(id);
SqlParameter fl = new SqlParameter("flag", SqlDbType.VarChar);
fl.Value = gm.flag;
cmd.Parameters.Add(fl);
Conn.Open();
cmd.ExecuteNonQuery();
Conn.Close();
}
catch (Exception Ex)
{
if (Conn.State == ConnectionState.Open)
{
Conn.Close();
}
throw Ex;
}
finally
{
if (Conn.State == ConnectionState.Open)
{
Conn.Close();
}
}
return(1);
}
protected async override Task OnInitializedAsync()
{
GroupObject = await GroupService.GetGroupById(int.Parse(Id));
GroupMembers = await GroupService.GetGroupMembers(GroupObject.Id);
GroupMembers.Remove(GroupObject.Owner);
CurrentUser = await UserService.GetAuthorizedUser(authenticationStateTask);
}
public Task Add(string connectionId, string groupName)
{
if (!GroupMembers.ContainsKey(groupName))
{
GroupMembers.Add(groupName, new List <string>());
}
GroupMembers[groupName].Add(connectionId);
return(Groups.Add(connectionId, groupName));
}
//同意群申请
public void AgreeGroup(Messages msg)
{
GroupMembers goupMember = dm.GroupMembers.Single(f => f.IsPass == false &&
f.GroupName == msg.Details &&
f.GroupMember == msg.Receiver);
goupMember.IsPass = true;
dm.Messages.InsertOnSubmit(msg);
dm.SubmitChanges();
}
public IActionResult AddGroupMember([FromBody] GroupMembers gm)
{
int res = _groupRepo.AddMemberToGroup(gm);
if (res != 0)
{
return(Ok(res));
}
return(Forbid());
}
public async Task <IActionResult> Create([Bind("Id,Name,Email")] GroupMembers groupMembers)
{
if (ModelState.IsValid)
{
_context.Add(groupMembers);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(groupMembers));
}
protected async void RefreshMembersList()
{
GroupObject = await GroupService.GetGroupById(GroupObject.Id);
GroupMembers = await GroupService.GetGroupMembers(GroupObject.Id);
GroupMembers.Remove(GroupObject.Owner);
CurrentUser = await UserService.GetAuthorizedUser(authenticationStateTask);
StateHasChanged();
}
// ╔════╤════════════════════════════════════════════════════════╗
// ║ 4d │ M E T H O D S ( P U B L I C ) ║
// ╟────┴────────────────────────────────────────────────────────╢
// ║ N O N - S T A T I C & S T A T I C ║
// ╚═════════════════════════════════════════════════════════════╝
#region ═╣ M E T H O D S ( P U B L I C ) ╠═
/// <summary>
/// Adds a already connected user to the group.
/// The user reconnects at the next session.
/// </summary>
/// <param name="pUser">Client</param>
public void AddUser(NetComUser pUser)
{
if (!OnlineMembers.Contains(pUser))
{
OnlineMembers.Add(pUser);
}
if (!GroupMembers.Contains(pUser.Username.ToLower()))
{
GroupMembers.Add(pUser.Username.ToLower());
}
}
private void AddGroupMembers(SPGroup group)
{
if (!string.IsNullOrEmpty(GroupMembers))
{
string[] logins = GroupMembers.Split(';');
foreach (string login in logins)
{
group.Users.Add(login, "", "", "");
}
group.Update();
}
}
public IActionResult AddMember(GroupMembers newMember, int groupId)
{
if (ModelState.IsValid)
{
_context.Add(newMember);
_context.SaveChanges();
return(RedirectToAction("GroupDetails", new { groupId }));
}
else
{
return(View());
}
}