public async Task <List <EmployeeListOutput> > GetListByIdsAsync(Guid[] ids)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from item in db.Employees
where ids.Contains(item.Id)
orderby item.Number
select item;
return(await query.ProjectTo <EmployeeListOutput>(_mapper.ConfigurationProvider)
.ToListAsync());
}
}
public async Task <List <DepartmentListOutput> > GetListByParentIdAsync(Guid id)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from item in db.Departments
where item.ParentId == id
orderby item.Sort, item.Name
select item;
return(await query.ProjectTo <DepartmentListOutput>(_mapper.ConfigurationProvider)
.ToListAsync());
}
}
public async Task <List <DepartmentListOutput> > SearchByKeywordAsync(string keyword)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from item in db.Departments
where item.Name.Contains(keyword)
orderby item.Sort, item.Name
select item;
return(await query.ProjectTo <DepartmentListOutput>(_mapper.ConfigurationProvider)
.ToListAsync());
}
}
public async Task <List <GroupListOutput> > GetListByEmployeeIdAsync(Guid employeeId)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from g in db.Groups
where g.Type != GroupType.WhiteListChat
from m in g.Members
where m.EmployeeId == employeeId
select g;
return(await query.ProjectTo <GroupListOutput>(_mapper.ConfigurationProvider)
.ToListAsync());
}
}
public async Task <List <Guid> > GetUserIdsByDepartmentIdAsync(Guid departmentId)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from item in db.Employees
where item.UserId.HasValue
from ep in item.Positions
join pos in db.Positions.Where(o => o.DepartmentId == departmentId)
on ep.PositionId equals pos.Id
orderby item.Number
select item.UserId.Value;
return(await query.ToListAsync());
}
}
public async Task <List <DepartmentListOutput> > GetRootListAsync()
{
using (var db = new ServiceDbContext(_dbOptions))
{
var query = from item in db.Departments
where item.ParentId == null
join child in db.Departments on item.Id equals child.ParentId
orderby child.Sort, child.Name
select child;
var result = await query.ProjectTo <DepartmentListOutput>(_mapper.ConfigurationProvider)
.ToListAsync();
return(result);
}
}
public async Task <Guid> CreateCustomAsync(GroupInput input)
{
if (string.IsNullOrWhiteSpace(input.Name))
{
throw new ArgumentNullException("must not be null", nameof(input.Name));
}
if (input.CurrentUserId == Guid.Empty)
{
throw new ArgumentNullException("must not be empty", nameof(input.CurrentUserId));
}
if (!input.CurrentEmployeeId.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.CurrentEmployeeId));
}
using (var db = new ServiceDbContext(_dbOptions))
{
using (var tx = db.Database.BeginTransaction())
{
try
{
var entity = _mapper.Map <Group>(input);
entity.Type = GroupType.CustomChat;
db.Groups.Add(entity);
await db.SaveChangesAsync();
await _busMs.Publish(new GroupAdded
{
Id = entity.Id
});
tx.Commit();
return(entity.Id);
}
catch (Exception ex)
{
tx.Rollback();
_logger.Error(ex, "CreateCustomAsync Transaction rollback");
throw;
}
}
}
}
public async Task <EmployeeOutput> GetByUserIdAsync(Guid userId)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var dto = await db.Employees.Where(o => o.UserId == userId)
.ProjectTo <EmployeeOutput>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync();
if (dto != null)
{
var query = from item in db.EmployeePositions
where item.EmployeeId == dto.Id && !item.IsPrimary
select item.PositionId;
dto.ParttimePositionIds = await query.ToListAsync();
}
return(dto);
}
}
public async Task <GroupOutput> GetDepGroupByIdAsync(Guid id)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var dto = await db.Departments
.Where(x => x.Id == id)
.Select(x => new GroupOutput
{
Created = DateTimeOffset.UtcNow,
CreatedBy = Guid.Empty,
Id = x.Id,
Name = x.Name,
Type = GroupType.DepartmentChat,
Updated = DateTimeOffset.UtcNow
})
.FirstOrDefaultAsync();
if (dto == null)
{
return(null);
}
var query = from e in db.Employees
from ep in e.Positions
join pos in db.Positions.Where(o => o.DepartmentId == id)
on ep.PositionId equals pos.Id
orderby e.Number
select new GroupMemberOutput
{
EmployeeId = e.Id,
EmployeeName = e.Name,
Gender = e.Gender,
IsOwner = false,
Joined = DateTimeOffset.UtcNow,
PrimaryDepartmentId = e.PrimaryDepartmentId
};
dto.Members = await query.ToListAsync();
return(dto);
}
}
private Task <List <EmployeeListOutput> > SelectByDepartmentId(ServiceDbContext db, Guid departmentId)
{
//兼职人员也返回
var query = from item in db.Employees
from ep in item.Positions
join pos in db.Positions.Where(o => o.DepartmentId == departmentId)
on ep.PositionId equals pos.Id
orderby item.Number
select new EmployeeListOutput
{
Id = item.Id,
Name = item.Name,
PositionId = pos.Id,
PositionName = pos.Name,
PrimaryDepartmentId = item.PrimaryDepartmentId,
PrimaryPositionId = item.PrimaryPositionId
};
return(query.ToListAsync());
}
public async Task <bool> CheckSameWhiteListGroupAsync(Guid currentEmployeeId, Guid targetEmployeeId)
{
using (var db = new ServiceDbContext(_dbOptions))
{
var queryTargetGroup = from g in db.Groups
from m in g.Members
where g.Type == GroupType.WhiteListChat && m.EmployeeId == targetEmployeeId
select g;
if (await queryTargetGroup.CountAsync() == 0)
{
return(true);
}
var query = from m in db.GroupMembers
where m.EmployeeId == currentEmployeeId
join tg in queryTargetGroup
on m.GroupId equals tg.Id
select m;
var count = await query.CountAsync();
return(count > 0);
}
}
public async Task <RemotingResult> ScanJoinAsync(string code, Guid employeeId, string employeeName)
{
if (code == null)
{
throw new ArgumentNullException(nameof(code));
}
if (employeeId == Guid.Empty)
{
throw new ArgumentException("must not be empty", nameof(employeeId));
}
var splited = code.Split(',');
if (splited.Length != 2)
{
return(RemotingResult.Fail(1));
}
if (!Guid.TryParse(splited[0], out Guid id))
{
return(RemotingResult.Fail(1));
}
if (!Guid.TryParse(splited[1], out Guid _))
{
return(RemotingResult.Fail(1));
}
var originalFingerprint = await _simpleKeyValueService.CheckAndGet(SKVContainer_ScanJoinCode,
id.ToString("N"), TimeSpan.FromDays(1));
if (splited[1] != originalFingerprint)
{
return(RemotingResult.Fail(1));
}
using (var db = new ServiceDbContext(_dbOptions))
{
using (var tx = db.Database.BeginTransaction())
{
try
{
var entity = await db.Groups.Include(o => o.Members)
.Where(o => o.Type == GroupType.CustomChat)
.FirstOrDefaultAsync(o => o.Id == id);
if (entity == null)
{
return(RemotingResult.Fail(2));
}
if (entity.Members.Exists(o => o.EmployeeId == employeeId))
{
return(RemotingResult.Fail(3));
}
entity.Members.Add(new GroupMember
{
EmployeeId = employeeId,
GroupId = id,
Joined = DateTimeOffset.UtcNow,
});
await db.SaveChangesAsync();
await _busMs.Publish(new GroupMembersUpdated { Id = entity.Id });
await _busMs.Publish(new GroupNotified
{
Id = entity.Id,
Notifies = new List <EventNotifyDto>
{
new EventNotifyDto
{
Target = NotifyTargetType.Conversation,
TargetId = entity.Id.ToString(),
Created = DateTimeOffset.UtcNow,
Text = employeeName,
TargetCategory = (int)GroupEventNotifyType.ParticipantAdded
}
}
});
tx.Commit();
return(RemotingResult.Success());
}
catch (Exception ex)
{
tx.Rollback();
_logger.Error(ex, "UpdateAsync Transaction rollback");
return(RemotingResult.Fail());
}
}
}
}
public async Task <RemotingResult> QuitAsync(GroupInput input)
{
if (!input.Id.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.Id));
}
if (!input.CurrentEmployeeId.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.CurrentEmployeeId));
}
using (var db = new ServiceDbContext(_dbOptions))
{
using (var tx = db.Database.BeginTransaction())
{
try
{
var entity = await db.Groups
.Include(o => o.Members)
.FirstOrDefaultAsync(o => o.Id == input.Id);
if (entity == null)
{
return(RemotingResult.Fail());
}
var member = entity.Members.Find(o => o.EmployeeId == input.CurrentEmployeeId.Value);
if (member == null)
{
return(RemotingResult.Fail());
}
if (member.IsOwner)
{
return(RemotingResult.Fail(FailedCodes.Group_OwnerCannotQuit));
}
entity.Members.Remove(member);
await db.SaveChangesAsync();
await _busMs.Publish(new GroupMembersUpdated { Id = entity.Id });
await _busMs.Publish(new GroupNotified
{
Id = entity.Id,
Notifies = new List <EventNotifyDto>
{
new EventNotifyDto
{
Target = NotifyTargetType.Conversation,
TargetId = input.Id.ToString(),
Created = DateTimeOffset.UtcNow,
Text = input.CurrentEmployeeName,
TargetCategory = (int)GroupEventNotifyType.ParticipantQuited
}
}
});
tx.Commit();
return(RemotingResult.Success());
}
catch (Exception ex)
{
tx.Rollback();
_logger.Error(ex, "QuitAsync Transaction rollback");
return(RemotingResult.Fail());
}
}
}
}
public async Task <RemotingResult> DeleteAsync(GroupInput input)
{
if (!input.Id.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.Id));
}
if (input.CurrentUserId == Guid.Empty)
{
throw new ArgumentNullException("must not be empty", nameof(input.CurrentUserId));
}
using (var db = new ServiceDbContext(_dbOptions))
{
using (var tx = db.Database.BeginTransaction())
{
try
{
var entity = await db.Groups.FirstOrDefaultAsync(o => o.Id == input.Id);
if (entity == null)
{
return(RemotingResult.Fail());
}
if (entity.CreatedBy != input.CurrentUserId)
{
return(RemotingResult.Fail(FailedCodes.Group_NotCreatedBy));
}
db.Groups.Remove(entity);
await db.SaveChangesAsync();
await _busMs.Publish(new GroupDeleted { Id = entity.Id });
await _busMs.Publish(new GroupNotified
{
Id = entity.Id,
Notifies = new List <EventNotifyDto>
{
new EventNotifyDto
{
Target = NotifyTargetType.Conversation,
TargetId = entity.Id.ToString(),
Created = DateTimeOffset.UtcNow,
Text = entity.Name,
TargetCategory = (int)GroupEventNotifyType.GroupDismissed
}
}
});
tx.Commit();
return(RemotingResult.Success());
}
catch (Exception ex)
{
tx.Rollback();
_logger.Error(ex, "DeleteAsync Transaction rollback");
return(RemotingResult.Fail());
}
}
}
}
public async Task <RemotingResult> UpdateAsync(GroupInput input)
{
if (!input.Id.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.Id));
}
if (input.CurrentUserId == Guid.Empty)
{
throw new ArgumentNullException("must not be empty", nameof(input.CurrentUserId));
}
if (input.RemovingMemberIds?.Count > 0)
{
//如果需要删除成员，那么就需要传递当前员工Id
if (!input.CurrentEmployeeId.HasValue)
{
throw new ArgumentNullException("must not be null", nameof(input.CurrentEmployeeId));
}
if (input.RemovingMemberIds.Contains(input.CurrentEmployeeId.Value))
{
return(RemotingResult.Fail(FailedCodes.Group_CannotRemoveOwner));
}
}
using (var db = new ServiceDbContext(_dbOptions))
{
using (var tx = db.Database.BeginTransaction())
{
try
{
var entity = await db.Groups.FirstOrDefaultAsync(o => o.Id == input.Id);
if (entity == null)
{
return(RemotingResult.Fail());
}
if (entity.CreatedBy != input.CurrentUserId)
{
return(RemotingResult.Fail(FailedCodes.Group_NotCreatedBy));
}
var nameUpdated = false;
if (!string.IsNullOrWhiteSpace(input.Name) && entity.Name != input.Name)
{
entity.Name = input.Name;
nameUpdated = true;
}
if (input.Remark != null)
{
entity.Remark = input.Remark;
}
var membersUpdated = false;
if (input.AddingMemberIds?.Count > 0 ||
input.RemovingMemberIds?.Count > 0)
{
//需要编辑成员，就显式加载成员集合
await db.Entry(entity).Collection(o => o.Members).LoadAsync();
membersUpdated = true;
}
if (input.AddingMemberIds != null)
{
foreach (var employeeId in input.AddingMemberIds)
{
if (!entity.Members.Exists(o => o.EmployeeId == employeeId))
{
entity.Members.Add(new GroupMember
{
EmployeeId = employeeId,
GroupId = input.Id.Value,
Joined = DateTimeOffset.UtcNow,
});
}
}
}
if (input.RemovingMemberIds != null)
{
var willRemoving = new List <GroupMember>();
foreach (var employeeId in input.RemovingMemberIds)
{
var m = entity.Members.Find(o => o.EmployeeId == employeeId);
willRemoving.Add(m);
}
willRemoving.ForEach(o => entity.Members.Remove(o));
}
await db.SaveChangesAsync();
if (membersUpdated)
{
await _busMs.Publish(new GroupMembersUpdated { Id = entity.Id });
}
await SendEventNotifyForUpdateAsync(nameUpdated, input);
tx.Commit();
return(RemotingResult.Success());
}
catch (Exception ex)
{
tx.Rollback();
_logger.Error(ex, "UpdateAsync Transaction rollback");
return(RemotingResult.Fail());
}
}
}
}