public async Task <IActionResult> AddGroup([FromBody] GroupAddModel groupAddModel)
{
var user = await _userService.GetOneByEmail(User.Identity.Name);
await _groupService.AddGroup(groupAddModel, user);
return(Ok(new { message = "Grupo criado com sucesso." }));
}
public async Task <GroupManageModel> AddAsync(GroupAddModel model)
{
_unitOfWork.BeginTransaction();
var addedModel = await _repository.AddAsync(_mapper.Map <GroupModel>(model));
var result = await _unitOfWork.CommitAsync();
return(result > 0 ? _mapper.Map <GroupManageModel>(addedModel) : null);
}
public async Task AddGroup(GroupAddModel groupAddModel, User user)
{
groupAddModel.Validate();
var group = groupAddModel.ConvertToGroup(user);
await _context.Groups.AddAsync(group);
await _context.GroupUsers.AddAsync(new GroupUser { Group = group, User = user });
await _context.SaveChangesAsync();
}
public async Task <IActionResult> AddAsync([FromBody] GroupAddModel mGroup)
{
if (!ModelState.IsValid)
{
return(HttpBadRequest(ModelStateError()));
}
var groupId = await _groupRepository.AddAsync(mGroup);
return(CreatedAtRoute("GetByGroupIdAsync", new { controller = "Groups", groupId = groupId }, mGroup));
}
public async Task <IResultModel> Add(GroupAddModel model)
{
var entity = _mapper.Map <GroupEntity>(model);
//if (await _repository.Exists(entity))
//{
//return ResultModel.HasExists;
//}
var result = await _repository.AddAsync(entity);
return(ResultModel.Result(result));
}
public ActionResult GroupEdit(int id)
{
Tbl_Group q = new Tbl_Group();
q = db.Tbl_Group.Where(a => a.Group_ID == id).SingleOrDefault();
GroupAddModel model = new GroupAddModel();
model.ID = q.Group_ID;
model.Name = q.Group_Name;
return(View(model));
}
public async Task <IResultModel> Add(GroupAddModel model)
{
var entity = _mapper.Map <GroupEntity>(model);
if (await _repository.Exists(entity))
{
return(ResultModel.Failed("编码已存在"));
}
var result = await _repository.AddAsync(entity);
return(ResultModel.Result(result));
}
public async Task Group_PostWithInvalidUser2_ShouldReturnForbid()
{
var model = new GroupAddModel
{
Name = "New user",
Users = new List <UserModelBase>()
{
new UserModelBase {
Id = DefaultInvalidUser
}
}
};
var results = await _controller.Post(model);
results.Should().BeOfType <ForbidResult>();
}
public async Task <IActionResult> Post([FromBody] GroupAddModel value)
{
var userId = _validateHelper.GetUserId(HttpContext);
if (value != null && !value.Users.Any(u => u.Id.Equals(userId)))
{
return(Forbid());
}
var model = await _groupService.AddAsync(value);
if (model == null)
{
return(BadRequest());
}
return(Ok(model));
}
public ActionResult GroupAdd(GroupAddModel model)
{
Tbl_Group q = new Tbl_Group();
q.Group_Name = model.Name;
db.Tbl_Group.Add(q);
if (Convert.ToBoolean(db.SaveChanges() > 0))
{
return(RedirectToAction("GroupList", "Setting"));
}
else
{
return(View());
}
}
public async Task <int> AddAsync(GroupAddModel group)
{
//Chech whether the Foreign key ProjectId data exist
var project = _context.Projects.FirstOrDefault(p => p.ProjectId == group.ProjectId);
if (project == null)
{
throw new ExpectException("Could not find Project data which ProjectId equal to " + group.ProjectId);
}
//If SceneId not null,check whether corresponding Scenes data existed
if (group.SceneId != null)
{
var scene = _context.Scenes.FirstOrDefault(p => p.SceneId == group.SceneId);
if (scene == null)
{
throw new ExpectException("Could not find Scenes data which SceneId equal to " + group.SceneId);
}
}
//GroupName must be unique
var checkData = await _context.Groups.Where(g => g.GroupName == group.GroupName).ToListAsync();
if (checkData.Count > 0)
{
throw new ExpectException("The data which GroupName equal to '" + group.GroupName + "' already exist in system.");
}
//Get UserInfo
var user = _loginUser.GetLoginUserInfo();
var model = new Group
{
GroupName = group.GroupName,
ProjectId = group.ProjectId,
SceneId = group.SceneId,
Creator = user.UserName,
CreateDate = DateTime.Now
};
_context.Groups.Add(model);
await _context.SaveChangesAsync();
return(model.GroupId);
}
public async Task Group_Post_ShouldReturnData()
{
var model = new GroupAddModel
{
Name = "New user",
Users = new List <UserModelBase>()
{
new UserModelBase {
Id = DefaultUser
}
}
};
var results = await _controller.Post(model);
results
.Should().BeOfType <OkObjectResult>()
.Which.Value.Should().BeAssignableTo <GroupManageModel>()
.Which.Should().NotBeNull();
}
public IActionResult AddG([FromBody] GroupAddModel model)
{
GroupAddReturn ret = new GroupAddReturn();
try
{
if (!ModelState.IsValid)
{
ret.ErrorInformation.UserInformation = "An error has occured";
return(Ok(Json(ret)));
}
if (_groupDataService.IsUrlKeyAlreadyExist(model.Urlkey))
{
ret.ErrorInformation.UserInformation = "There is already a group with id " + model.Urlkey;
return(Ok(Json(ret)));
}
Group groupToAdd = new Group()
{
DateUtcAdd = DateTime.Now,
DateUtcModified = DateTime.Now,
Description = model.Description,
Name = model.Name,
UrlKey = model.Urlkey
};
_groupService.Add(groupToAdd);
ret.IsActionSucceed = true;
ret.SuccessInformation = new SuccessReturnInformation()
{
RedirectUrl = "group/" + model.Urlkey,
SuccessType = SuccessType.Redirect,
UserInformation = "The new group is added",
};
return(Ok(Json(ret)));
}
catch (Exception ex)
{
ret.ErrorInformation.UserInformation = "An error has occured -> " + ex.Message;
return(Ok(Json(ret)));
}
}
public Task <IResultModel> Add(GroupAddModel model)
{
return(_service.Add(model));
}
