[HttpGet] // Added during testing
public async Task <object> updateConnect(string connectId, bool status) // return type made to object during testing
{
Connect connect = context.Connects.FirstOrDefault(x => x.Id == connectId);
if (connect != null)
{
if (status)
{
GroupMapper gpm = context.GroupMappers.FirstOrDefault(x => x.Id == connect.groupMapperId);
if (gpm != null)
{
Person person = context.People.FirstOrDefault(x => x.Id == gpm.personId);
if (person != null)
{
person.isGloballyVisible = true;
gpm.isPersonVisibleInGroup = true;
connect.status = status;
await context.SaveChangesAsync();
}
}
}
else
{
await DeleteConnect(connectId);
}
}
return(new object());
}
public ManagerController(IGroupProvider groupProvider,
IProjectProvider projectProvider,
IScrumMasterProvider scrumMasterProvider,
ITraineeProvider traineeProvider,
TraineeMapper traineeMapper,
IMentorProvider mentorProvider,
ISpecializationProvider specializationProvider,
IUsersProvider userProvider,
ProjectMapper projectMapper,
GroupMapper groupMapper,
MentorMapper mentorMapper,
UserMapper userMapper,
RoleMapper roleMapper)
{
_groupProvider = groupProvider;
_projectProvider = projectProvider;
_scrumMasterProvider = scrumMasterProvider;
_traineeProvider = traineeProvider;
_traineeMapper = traineeMapper;
_mentorProvider = mentorProvider;
_specializationProvider = specializationProvider;
_userProvider = userProvider;
_projectMapper = projectMapper;
_groupMapper = groupMapper;
_mentorMapper = mentorMapper;
_userMapper = userMapper;
_roleMapper = roleMapper;
}
public IEnumerable <GroupDto> GetAllGroups(Guid tenantid, Guid companyid)
{
IEnumerable <Group> groupList = _unitOfWork.GroupRepository.GetMany(Group => Group.TenantId == tenantid && Group.CompanyId == companyid);
IEnumerable <GroupDto> groupDtoList = groupList.Select(group => GroupMapper.EntityMapToDto(group));
return(groupDtoList);
}
public async Task <object> addConnect(string groupId, string personId, bool addMyself)
{
GroupMapper gpm = context.GroupMappers.FirstOrDefault(x => x.personId == personId);
Person person = context.People.FirstOrDefault(x => x.Id == personId);
if (addMyself)
{
if (gpm != null && (context.Connects.FirstOrDefault(x => x.groupMapperId == gpm.Id) != null))
{
foreach (var connect in context.Connects.Where(x => x.groupMapperId == gpm.Id).ToList <Connect>())
{
await DeleteConnect(connect.Id);
}
}
}
if (gpm.isPersonVisibleInGroup && person != null && person.isGloballyVisible)
{
await PostConnect(new Connect
{
Id = Guid.NewGuid().ToString(),
groupMapperId = gpm.Id,
status = addMyself
});
return(new object());
}
return(null);
}
public async Task addConnect2(string groupId, string personId, bool addMyself)
{
if (addMyself)
{
if (context.GroupMappers.FirstOrDefault(x => x.personId == personId) != null)
{
List <GroupMapper> groupMapperList = context.GroupMappers.Where(x => x.personId == personId).ToList();
foreach (var gpm in groupMapperList)
{
Connect tempConnect = context.Connects.FirstOrDefault(x => x.groupMapperId == gpm.Id);
if (tempConnect != null)
{
await DeleteConnect(tempConnect.Id);
}
}
}
}
Person person = context.People.FirstOrDefault(x => x.Id == personId);
GroupMapper gpm2 = context.GroupMappers.FirstOrDefault(x => x.groupId == groupId && x.personId == personId);
if (person != null && person.isGloballyVisible && gpm2 != null && gpm2.isPersonVisibleInGroup)
{
if (context.Connects.FirstOrDefault(x => x.groupMapperId == gpm2.Id) == null)
{
await PostConnect(new Connect
{
Id = Guid.NewGuid().ToString(),
groupMapperId = gpm2.Id,
status = addMyself
});
}
}
}
public void Arrange()
{
_translatorMock = new Mock <ITranslator>();
_mapper = new GroupMapper(_translatorMock.Object);
_cancellationToken = new CancellationToken();
}
public async Task <QueryResult <GroupDto> > GetProjectGroupsAsync(int projectId, TabularData tabularData,
Func <Sorting, string> sort = null)
{
if (projectId < 1)
{
throw new ArgumentOutOfRangeException(nameof(projectId));
}
var orderField = string.Empty;
if (sort != null && tabularData.Sorting != null)
{
orderField = sort(tabularData.Sorting);
}
if (!string.IsNullOrWhiteSpace(tabularData.Search))
{
tabularData.Search = UsersHelper.ReplaceWildcardCharacters(tabularData.Search);
}
var prm = new DynamicParameters();
prm.Add("@projectId", projectId);
prm.Add("@Offset", tabularData.Pagination.Offset);
prm.Add("@Limit", tabularData.Pagination.Limit);
prm.Add("@OrderField", orderField);
prm.Add("@Search", tabularData.Search);
prm.Add("@Total", dbType: DbType.Int32, direction: ParameterDirection.Output);
prm.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var result =
(await
_connectionWrapper.QueryAsync <Group>("GetAvailableGroupsForProject", prm,
commandType: CommandType.StoredProcedure)).ToList();
var errorCode = prm.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.ProjectWithCurrentIdNotExist:
throw new ResourceNotFoundException(ErrorMessages.ProjectNotExist, ErrorCodes.ResourceNotFound);
}
}
var total = prm.Get <int?>("Total");
var queryDataResult = new QueryResult <GroupDto> {
Items = GroupMapper.Map(result), Total = total ?? 0
};
return(queryDataResult);
}
public async Task <QueryResult <GroupDto> > GetUserGroupsAsync(int userId, TabularData tabularData, Func <Sorting, string> sort = null)
{
var orderField = string.Empty;
if (sort != null && tabularData.Sorting != null)
{
orderField = sort(tabularData.Sorting);
}
if (!string.IsNullOrWhiteSpace(tabularData.Search))
{
tabularData.Search = UsersHelper.ReplaceWildcardCharacters(tabularData.Search);
}
var parameters = new DynamicParameters();
parameters.Add("@UserId", userId);
parameters.Add("@Offset", tabularData.Pagination.Offset);
parameters.Add("@Limit", tabularData.Pagination.Limit);
parameters.Add("@OrderField", orderField);
parameters.Add("@Search", tabularData.Search);
parameters.Add("@Total", dbType: DbType.Int32, direction: ParameterDirection.Output);
parameters.Add("@ErrorCode", dbType: DbType.Int32, direction: ParameterDirection.Output);
var userGroups = await _connectionWrapper.QueryAsync <Group>("GetUsersGroups", parameters, commandType : CommandType.StoredProcedure);
var total = parameters.Get <int?>("Total");
var errorCode = parameters.Get <int?>("ErrorCode");
if (errorCode.HasValue)
{
switch (errorCode.Value)
{
case (int)SqlErrorCodes.GeneralSqlError:
throw new BadRequestException(ErrorMessages.GeneralErrorOfGettingUserGroups);
case (int)SqlErrorCodes.UserLoginNotExist:
throw new ResourceNotFoundException(ErrorMessages.UserNotExist, ErrorCodes.ResourceNotFound);
}
}
if (!total.HasValue)
{
throw new BadRequestException(ErrorMessages.TotalNull);
}
var mappedGroups = GroupMapper.Map(userGroups);
var queryDataResult = new QueryResult <GroupDto>()
{
Items = mappedGroups, Total = total.Value
};
return(queryDataResult);
}
public async Task <HueGroup> GetGroup(string id, CancellationToken cancellationToken)
{
Group?group = await _hueClient.GetGroupAsync(id);
if (group == null)
{
throw new NotFoundException(id);
}
return(GroupMapper.Map(group));
}
[HttpGet] // Added during testing
public Connect getConnectUsingPersonAndGroup(string groupId, string personId)
{
GroupMapper groupMapper = context.GroupMappers.FirstOrDefault(x => x.groupId == groupId && x.personId == personId);
Connect connect = null;
if (groupMapper != null)
{
connect = context.Connects.FirstOrDefault(x => x.groupMapperId == groupMapper.Id);
}
return(connect);
}
public GridViewModel GetSearchResult(SearchRequest request)
{
var model = GroupMapper.CreateGridViewModel();
var pageResult = QueryListHelper.SortResults(GetAllGroups(), request);
var serviceRows = pageResult
.Where(p => string.IsNullOrEmpty(request.SearchText) || p.Name.StartsWith(request.SearchText, StringComparison.CurrentCultureIgnoreCase))
.Select(GroupMapper.BindGridData);
model.Rows = serviceRows.ToPagedList(request.Page ?? 1, request.PageSize);
return(model);
}
public async Task <ActionResult <IEnumerable <GroupOutputModel> > > GetAllGroupByUser(int userId)
{
if (userId.Equals(null))
{
return(BadRequest("Group Id is empty"));
}
var result = GroupMapper.ToOutputModels(await groupStorage.GetTeacherGroupsById(userId));
if (result.Equals(null))
{
return(BadRequest("Failed to add object"));
}
return(Ok(result));
}
public GroupDto CreateGroup(string adminUserName, string groupName)
{
UserIdentity adminUser = m_UserRepository.Set().Where(p => p.UserName == adminUserName).FirstOrDefault();
Group group = new Group();
group.GroupAdminUser = adminUser;
group.Name = groupName;
m_GroupRepository.Set().Add(group);
m_GroupRepository.SaveChanges();
AddParticipant(groupName, adminUserName);
return(GroupMapper.MapToDto(group));
}
public void Initialize()
{
var groupProfile = new GroupMapper();
var smartLockMapper = new SmartLockMapper();
var userMapper = new UserMapper();
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(groupProfile);
cfg.AddProfile(smartLockMapper);
cfg.AddProfile(userMapper);
});
_mapper = new Mapper(config);
}
public async Task <GroupDto> GetGroupDetailsAsync(int groupId)
{
var parameters = new DynamicParameters();
parameters.Add("@GroupId", groupId);
var result =
await
_connectionWrapper.QueryAsync <Group>("GetGroupDetails", parameters,
commandType : CommandType.StoredProcedure);
var enumerable = result as IList <Group> ?? result.ToList();
var group = enumerable.Any() ? enumerable.First() : new Group();
return(GroupMapper.Map(group));
}
public ScrumMasterController(
IScrumReviewProvider scrumReviewProvider,
IScrumMasterProvider scrumMasterProvider,
IGroupProvider groupProvider,
IProjectProvider projectProvider,
ScrumReviewMapper scrumMasterMapper,
GroupMapper groupMapper,
ProjectMapper projectMapper,
ICurrentUserFactory userFactory)
: base(userFactory)
{
_scrumReviewProvider = scrumReviewProvider;
_scrumMasterProvider = scrumMasterProvider;
_scrumMasterMapper = scrumMasterMapper;
_groupProvider = groupProvider;
_projectProvider = projectProvider;
_groupMapper = groupMapper;
_projectMapper = projectMapper;
}
public GroupDto GetByName(string groupName)
{
Group group = m_GroupRepository.Set().Where(p => p.Name == groupName).FirstOrDefault();
return(group == null ? null : GroupMapper.MapToDto(group));
}
public IEnumerable <IGroup> GetUserGroups(Guid userId)
{
var mapper = new GroupMapper();
return(mapper.Map(queryService.GetUserGroups(userId)));
}
public IGroup GetGroup(Guid groupId)
{
var mapper = new GroupMapper();
return(mapper.Map(queryService.GetGroup(groupId)));
}
public IEnumerable <IGroup> GetGroups()
{
var mapper = new GroupMapper();
return(mapper.Map(queryService.GetGroups()));
}
