public void DeleteGroup_OK_正常値で削除()
{
var requestObject = new GroupCreateRequest
{
GroupCode = new String('T', 20),
GroupTree = new String('1', 8),
Name = new String('X', 256),
Description = new String('X', 1024),
Status = GroupStatus.NORMAL.ToString(),
SortNo = int.MaxValue,
Tags = new List <string> {
new String('X', 100)
},
};
var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/groups");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var group = JsonUtil.Deserialize <Group>(responseBody);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
request = new HttpRequestMessage(HttpMethod.Delete, $"/api/v1/groups/{group.GroupId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public void CreateGroup_ValidationError_すべての値が異常値()
{
var requestObject = new GroupCreateRequest
{
GroupCode = new String('Z', 21),
GroupTree = new String('Z', 9),
Name = new String('Z', 257),
Description = new String('Z', 1025),
Status = "ERROR",
SortNo = -1,
Tags = new List <string> {
new String('Z', 101)
},
};
var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/groups");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var error = JsonUtil.Deserialize <Error>(responseBody);
Assert.AreEqual(ErrorCodes.ValidationError, error.Code);
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("GroupCode", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("GroupTree", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Name", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Description", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Status", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("SortNo", StringComparison.OrdinalIgnoreCase)));
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("Tags", StringComparison.OrdinalIgnoreCase)));
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public async Task <bool> CreateGroup(GroupCreateRequest groupCreateRequest)
{
UserCredential = groupCreateRequest.Credential;
await AuthenticateAsync();
using (var pClient = new PowerBIClient(new Uri(POWER_BI_API_URL), PTokenCredentials))
{
var group = await pClient.Groups.CreateGroupWithHttpMessagesAsync(new GroupCreationRequest { Name = groupCreateRequest.GroupName }, true);
if (groupCreateRequest.Members.Any())
{
groupCreateRequest.Members.ForEach(async s =>
{
try
{
await pClient.Groups.AddGroupUserWithHttpMessagesAsync(group.Body.Id, new GroupUserAccessRight {
EmailAddress = s.MemberEmail, GroupUserAccessRightProperty = s.GroupUserAccessRight.GetRight()
});
}
catch (Exception e)
{
throw new ApplicationException(PowerResource.ProcessError_UserAssignment);
}
});
}
}
return(true);
}
public async Task <IActionResult> CreateGroupAsync([FromBody] GroupCreateRequest request)
{
var course = await courseService.GetCourseByIdAsync(request.CourseId);
if (course == null)
{
throw new BadRequestException("Course doesn't exist");
}
if (!await User.IsUniversityTeacherOrHigherAsync(course.UniversityId, universityService))
{
throw new ForbiddenException("Don't have rights to create a group for this course!");
}
var dto = new CreateGroupDTO
{
CourseId = request.CourseId,
TeacherEmail = request.TeacherEmail,
Name = request.GroupName
};
int id = await groupService.AddGroupAsync(dto);
return(Ok(new
{
id
}));
}
public async Task <bool> CreateGroup(GroupCreateRequest groupCreateRequest)
{
base.UserCredential = groupCreateRequest.Credential;
await AuthenticateAsync();
using (var pClient = new PowerBIClient(new Uri(POWER_BI_API_URL), PTokenCredentials))
{
var group = await pClient.Groups.CreateGroupWithHttpMessagesAsync(
new GroupCreationRequest { Name = groupCreateRequest.GroupName });
if (groupCreateRequest.Members.Any())
{
foreach (var s in groupCreateRequest.Members)
{
{
await pClient.Groups.AddGroupUserWithHttpMessagesAsync(group.Body.Id,
new GroupUserAccessRight
{
EmailAddress = s.MemberEmail, GroupUserAccessRightProperty = s.GroupUserAccessRight
});
}
}
}
}
return(false);
}
public async Task <BaseResponse> Create([FromBody] GroupCreateRequest request)
{
var response = new BaseResponse();
if (request == null || !ModelState.IsValid)
{
HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
response.Message = "Invalid input(s).";
return(response);
}
var group = new Group
{
Name = request.Name,
Private = request.Private,
Size = request.Size
};
try
{
Group createdGroup = null;
if (await _groupsRepository.Create(group))
{
createdGroup = await _groupsRepository.GetByName(group.Name);
}
else
{
throw new Exception();
}
if (createdGroup != null)
{
if (await _groupsRepository.AddUser(HttpContext.User.GetUserId(), createdGroup.Id))
{
response.Message = "Group successfully created!";
response.Success = true;
}
}
}
catch (Exception ex)
{
try
{
await _groupsRepository.Delete(group); // If the User addition fails, we need to delete the group we created.
}
catch {
Console.WriteLine(ex.Message);
HttpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
response.Message = "Failed to delete created group.";
}
Console.WriteLine(ex.Message);
HttpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
response.Message = "Failed to create group.";
}
return(response);
}
public async Task <GroupCreateResponse> CreateGroup(GroupCreateRequest request)
{
HttpResponseMessage response = await HttpClient.PostAsJsonAsync("api/v1/groups/create", request);
GroupCreateResponse ret = JsonConvert.DeserializeObject <GroupCreateResponse>(response.Content.ReadAsStringAsync().Result);
return(ret);
}
public async Task <IActionResult> Create([FromBody] GroupCreateRequest request)
{
var contract = mapper.Map <GroupContract>(request);
var id = await groupService.Create(contract);
return(Ok(new BaseIdResponse {
Id = id
}));
}
public async Task <IActionResult> CreateOne([FromBody] GroupCreateRequest request)
{
var res = await _context.Groups.AddAsync(_mapper.Map <Group>(request));
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(CreateOne),
await _context.Groups.ProjectTo <GroupGetAllResponse>(_mapper.ConfigurationProvider)
.FirstOrDefaultAsync(x => x.Id == res.Entity.Id)));
}
public async Task <Group> CreateAsync(
GroupCreateRequest group,
CancellationToken cancellationToken = default(CancellationToken))
{
var response = await CreateAsync <GroupResponse, GroupRequest <GroupCreateRequest> >(
GroupsResourceUri,
new GroupRequest <GroupCreateRequest>(group),
"create-group",
cancellationToken: cancellationToken
);
return(response?
.Group);
}
public async Task <bool> CreateGroupRequestAsync(GroupRequestInputModel model, ApplicationUser creator)
{
var request = new GroupCreateRequest()
{
Creator = creator,
Name = model.Name,
Description = model.Description,
Status = Status.Pending,
};
await this.groupCreateRepository.AddAsync(request);
await this.groupCreateRepository.SaveChangesAsync();
return(true);
}
public async Task <Group> CreateAsync(GroupCreateRequest group)
{
using (_loggerScope(_logger, "PostAsync")) // Maybe incluse the request in the log?
using (var client = _apiClient.CreateClient())
{
var response = await client.PostAsJsonAsync(GroupsResourceUri, group).ConfigureAwait(false);
if (response.StatusCode != System.Net.HttpStatusCode.Created)
{
throw new HttpRequestException(
$"Status code retrieved was {response.StatusCode} and not a 201 as expected" +
Environment.NewLine +
"See: https://developer.zendesk.com/rest_api/docs/core/groups#create-groups");
}
return(await response.Content.ReadAsAsync <Group>());
}
}
public Task <IActionResult> CreateGroup(GroupCreateRequest request)
{
//Creazione modello richiesto da admin
var model = new Group
{
Name = request.Name,
MatchId = request.MatchId
};
//Invocazione del service layer
var validations = BasicLayer.CreateGroup(model);
if (validations.Count > 0)
{
return(BadRequestTask(validations));
}
//Return contract
return(Reply(ContractUtils.GenerateContract(model)));
}
public void UpdateGroup_ValidationError_GroupTreeを重複する値で更新()
{
var requestObject = new GroupCreateRequest
{
GroupCode = new String('S', 20),
GroupTree = new String('4', 8),
Name = new String('S', 256),
Description = new String('S', 1024),
Status = GroupStatus.NORMAL.ToString(),
SortNo = int.MaxValue,
Tags = new List <string> {
new String('S', 100)
},
};
var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/groups");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(requestObject), Encoding.UTF8, "application/json");
var response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
var responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var group = JsonUtil.Deserialize <Group>(responseBody);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var updateRequestObject = new GroupUpdateRequest
{
GroupTree = "01",
};
request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/groups/{group.GroupId}");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", "normal-write");
request.Content = new StringContent(JsonUtil.Serialize(updateRequestObject), Encoding.UTF8, "application/json");
response = _httpclient.SendAsync(request).ConfigureAwait(false).GetAwaiter().GetResult();
responseBody = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
var error = JsonUtil.Deserialize <Error>(responseBody);
Assert.AreEqual(ErrorCodes.ValidationError, error.Code);
Assert.IsTrue(error.Details.Exists(e => e.Target.Equals("GroupTree", StringComparison.OrdinalIgnoreCase)));
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public ActionResult <Group> CreateGroup([FromBody] GroupCreateRequest request)
{
if (_groupQueryService.ExistsGroupCode(request.GroupCode))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupCode),
"groupCode"));
}
if (_groupQueryService.ExistsGroupTree(request.GroupTree))
{
return(ErrorObjectResultFactory.ValidationErrorDetail(
string.Format(ErrorMessages.ValidationDuplicated, ErrorMessages.DisplayGroupGroupTree),
"groupTree"));
}
var dto = _mapper.Map <GroupCreateRequest, GroupCreateDto>(request);
var entity = _groupService.CreateGroup(dto);
return(_mapper.Map <Domain.Entities.Group, Group>(entity));
}
public async Task <bool> CreatePowerBiGroup(GroupCreateRequestVM groupCreateRequest)
{
var request = new GroupCreateRequest {
Credential = new UserData
{
TenantId = groupCreateRequest.Credential.TenantId,
SecretId = groupCreateRequest.Credential.SecretId,
ApplicationId = groupCreateRequest.Credential.ApplicationId
},
GroupName = groupCreateRequest.GroupName,
Members = groupCreateRequest.Members.Select(s =>
{
var membersRights = new MembersRights
{
MemberEmail = s.MemberEmail,
GroupUserAccessRight = s.GroupUserAccessRight
};
return(membersRights);
}).ToArray()
};
var Result = await _powerService.CreateGroup(request);
return(Result);
}
public IActionResult Create(GroupCreateRequest command)
{
var group = _groupService.Create(command.Name, command.Description);
return(Created($"/api/group/{@group.Id}", null));
}
/// <summary>
/// Validates the specified request.
/// </summary>
/// <param name="request">The request.</param>
public static void Validate(GroupCreateRequest request)
{
CommentsWebServiceReflector.ValidateReflect(request);
}
