public async Task <IActionResult> Post([FromBody] GroupCreateDto @group)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState.Values.Select(value => value.Errors.FirstOrDefault()).FirstOrDefault()?.ErrorMessage));
}
if (await _groupsRepository.GetByName(@group.Name) != null)
{
return(new BadRequestObjectResult("Group name is already taken"));
}
try
{
var gr = await _groupsRepository.CreateWithOwner(@group, HttpContext.User.Identity.Name);
if (group.Users != null)
{
foreach (var user in group.Users)
{
await _groupsRepository.AddToGroup(user, gr.GroupGuid);
}
}
return(new OkObjectResult(new GroupFoundDto(gr)));
}
catch (ArgumentException ex)
{
return(new BadRequestObjectResult(ex.Message));
}
}
public async Task <IActionResult> CreateGroupWithUsers([FromBody] GroupCreateDto groupCreateDto)
{
var loggedInUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
if (groupCreateDto.UserId != loggedInUserId)
{
return(Unauthorized());
}
var user = await _userManager.FindByIdAsync(groupCreateDto.UserId.ToString());
if (user == null)
{
return(BadRequest("User doesnt exist"));
}
// check if currently LoggedIn User already a member of the group
bool isCurrentlyLoggedinUserAMemberAlready = await _groupRepo.CheckUserInGroup(user.Id, groupCreateDto.GroupName);
//check here if mentioned group has already in userHasGroups
// if so do everything other than creating group.
if (!isCurrentlyLoggedinUserAMemberAlready)
{
// first step create group
var group = await _groupRepo.CreateUserGroupnUserRole(user, groupCreateDto.GroupName, true);
if (!group)
{
return(BadRequest("Failed to create group"));
}
// then create UserGroup
}
// add group members
foreach (var id in groupCreateDto.GroupMembers)
{
var userMember = await _userManager.Users
.FirstOrDefaultAsync(kk => kk.Id == int.Parse(id));
bool isMemberAlready = await _groupRepo.CheckUserInGroup(userMember.Id, groupCreateDto.GroupName);
if (!isMemberAlready)
{
var group = await _groupRepo.CreateUserGroupnUserRole(userMember, groupCreateDto.GroupName, false);
if (!group)
{
return(BadRequest("Failed to create members in group"));
}
}
}
return(Ok("Created all successfully"));
}
public async Task <ActionResult> CreateGroup(GroupCreateDto group)
{
var authUser = await BasicUserFacade.GetUserByNickNameAsync(User.Identity.Name);
var group_Id = await GroupGenericFacade.CreateGroup(group, authUser.Id);
return(RedirectToAction("Index", "GroupsManager", new { groupId = group_Id }));
}
public virtual async Task <GroupDto> CreateAsync(GroupCreateDto input)
{
var group = ObjectMapper.Map <GroupCreateDto, Group>(input);
group = await _groupRepository.InsertAsync(group, autoSave : true);
return(ObjectMapper.Map <Group, GroupDto>(group));
}
public async Task <IActionResult> AddGroup([FromBody] GroupCreateDto group)
{
var result = await _groupService.AddGroup(group);
if (!result.Succeeded)
{
return(BadRequest(result.ErrorResult));
}
return(Ok(result.Content as GroupDto));
}
public IActionResult Update(int id, [FromBody] GroupCreateDto req)
{
if (req == null)
{
return(BadRequest());
}
var groupById = _posrepo.GetProductGroupById(id);
Mapper.Map(req, groupById);
_posrepo.UpdateProductGroup(groupById);
return(StatusCode(204));
}
public IActionResult Save([FromBody] GroupCreateDto req)
{
if (req == null)
{
return(BadRequest());
}
//var groupEntity = req;
var groupEntity = Mapper.Map <ProductGroup>(req);
_posrepo.SaveProductGroup(groupEntity);
return(CreatedAtRoute("GetCustomerById", new { id = groupEntity.Id }, groupEntity));
}
public async Task <GroupDto> Create(GroupCreateDto group)
{
var groupModel = group.Adapt <Group>();
groupModel.FormationDate = DateTime.Now;
var newGroup = await this.groupRepository.Create(groupModel);
await this.AddRelatedEntities(newGroup);
return(newGroup.Adapt <GroupDto>());
}
public async Task <int> CreateGroupAsync(GroupCreateDto groupDto)
{
var group = Mapper.Map <Group>(groupDto);
if (await GetIfGroupExistsAsync(group.Name))
{
throw new ArgumentException();
}
Repository.Create(group);
return(group.Id);
}
public async Task <ServiceResult> AddGroup(GroupCreateDto dto)
{
var user = await _userService.GetUser();
if (user == null)
{
return(ServiceResult.Error(ErrorsEnum.UserB2CMissing));
}
var newGroup = new Group
{
Name = dto.Name,
OwnerId = user.Id,
};
var group = await _db.Groups.AddAsync(newGroup);
await _db.SaveChangesAsync();
return(ServiceResult.Ok(_mapper.Map <GroupDto>(group.Entity)));
}
public async Task <int> CreateGroup(GroupCreateDto groupDto, int userId)
{
using (var uow = UnitOfWorkProvider.Create())
{
var groupId = await _groupService.CreateGroupAsync(groupDto);
var userToGroup = new AddUserToGroupDto()
{
GroupId = groupId,
UserId = userId,
IsAccepted = true
};
userToGroup.GroupId = groupId;
await _groupUserService.AddUserToGroupAsync(userToGroup, true);
await uow.Commit();
return(groupId);
}
}
public IActionResult Create([FromBody] GroupCreateDto data)
{
if (string.IsNullOrEmpty(data.Name))
{
return(BadRequest());
}
var group = new Group
{
IsPrivate = data.IsPrivate,
Name = data.Name,
Description = data.Description
};
var userId = ClaimsReader.GetUserId(Request);
var connection = new UserGroup
{
UserId = userId,
Group = group,
Relation = GroupRelation.Owner
};
context.Groups.Add(group);
context.UserGroups.Add(connection);
try
{
context.SaveChanges();
return(Ok());
}
catch (Exception)
{
return(BadRequest());
}
}
/// <inheritdoc/>
public Group CreateGroup(GroupCreateDto dto)
{
var now = DateUtil.Now;
var entity = new GroupTableEntity
{
GroupId = Guid.NewGuid(),
GroupCode = dto.GroupCode,
GroupTree = dto.GroupTree,
Name = dto.Name,
Description = dto.Description,
Status = dto.Status,
SortNo = dto.SortNo,
CreateTime = now,
UpdateTime = now,
};
using (var tran = new TransactionScope())
{
_groupRepository.Create(entity);
foreach (var tag in dto.Tags)
{
_tagRepository.Create(new TagTableEntity
{
TagId = Guid.NewGuid(),
TargetId = entity.GroupId,
Value = tag,
TargetTable = "Group",
CreateTime = now,
});
}
tran.Complete();
}
return(_groupQueryService.GetGroup(entity.GroupId));
}
public virtual Task <GroupDto> CreateAsync(GroupCreateDto input)
{
return(_groupAppService.CreateAsync(input));
}
public Task <GroupWithDetailsDto> CreateAsync(GroupCreateDto GroupCreate)
{
return(this.GroupCrudAppService.CreateAsync(GroupCreate));
}
public async Task <GroupDto> Post([FromBody] GroupCreateDto group)
{
return(await this.groupServices.Create(group));
}
