public async Task <IActionResult> Create([FromBody] CreateTagRequest request)
{
var existingTag = await _tagsService.GetTagByNameAsync(request.Name);
if (existingTag != null)
{
return(Conflict());
}
var tag = new Tag
{
Name = request.Name,
CreatorId = User.Claims.First(c => c.Type == "id").Value,
CreatedOn = DateTime.UtcNow
};
var created = await _tagsService.CreateAsync(tag);
if (!created)
{
return(BadRequest());
}
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUrl = $"{baseUrl}{ApiRoutes.Tags.GetAll}";
var response = _mapper.Map <TagResponse>(tag);
return(Created(
locationUrl,
response
));
}
public async Task <IActionResult> Create([FromBody] CreateTagRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResponse
{
Errors = ModelState.Values.SelectMany(x =>
x.Errors.Select(e => e.ErrorMessage))
}));
}
var newTag = new TagBuilder()
.WithName(request?.Name)
.WithAuthor(HttpContext.GetUserId())
.Build();
await _tagService
.CreateTagAsync(newTag)
.ConfigureAwait(false);
var locationUrl = _uriService
.GetTagUri(newTag.Id.ToString());
return(Created(locationUrl, new Response <TagResponse>(
_mapper.Map <TagResponse>(newTag))));
}
public async Task <IActionResult> Create([FromBody, Required] CreateTagRequest tagReqModel)
{
//if (!ModelState.IsValid)
//{
// return BadRequest("this is not good way to handle validations errors cuz we have to write this everywhere instead of this we are going to write a middleware and that will handle all validations"); ValidationFİlter.cs
//}
var tag = new Tag()
{
Name = tagReqModel.TagName,
CreatorId = HttpContext.GetUserId(),
CreatedOn = DateTime.UtcNow
};
var result = await postService.CreateTagAsync(tag);
if (!result)
{
return(BadRequest(new ErrorResponse {
Errors = new List <ErrorModel> {
new ErrorModel {
Message = "Unable to create tag"
}
}
}));
}
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUri = baseUrl + "/" + ApiRoutes.Tags.Get.Replace("{tagName}", tag.Name);
return(Created(locationUri, new Response <TagResponse>(mapper.Map <TagResponse>(tag))));
}
public async Task <ActionResult <int> > Update([FromRoute] int id, [FromBody] CreateTagRequest request)
{
Tag oldTag = _context.Tags.FirstOrDefault(x => x.Id == id);
if (oldTag == null)
{
return(NotFound());
}
var newTag = new Tag()
{
Name = request.Name,
};
List <CategoryTag> categoryTags = new List <CategoryTag>();
foreach (var item in request.CategoryNames)
{
var categoryTag = new CategoryTag();
categoryTag.TagId = newTag.Id;
categoryTag.CategoryId = _context.Categories.FirstOrDefault(category => category.Name == item).Id;
categoryTags.Add(categoryTag);
}
newTag.CategoryTags = categoryTags;
var oldData = _context.CategoryTags.Where(temp => temp.TagId == oldTag.Id);
foreach (var item in oldData)
{
_context.CategoryTags.Remove(item);
}
oldTag.Name = newTag.Name;
oldTag.CategoryTags = newTag.CategoryTags;
await _context.SaveChangesAsync();
return(Ok(oldTag));
}
public async Task <ActionResult <Tag> > Add([FromBody] CreateTagRequest request)
{
var newTag = new Tag()
{
Name = request.Name,
};
List <CategoryTag> categoryTags = new List <CategoryTag>();
if (request.CategoryNames != null)
{
foreach (var item in request.CategoryNames)
{
var categoryTag = new CategoryTag();
categoryTag.TagId = newTag.Id;
categoryTag.CategoryId = _context.Categories.FirstOrDefault(category => category.Name == item).Id;
categoryTags.Add(categoryTag);
}
}
newTag.CategoryTags = categoryTags;
_context.Tags.Add(newTag);
_context.SaveChanges();
return(Ok(newTag));
}
public async Task <IActionResult> Create([FromBody] CreateTagRequest request)
{
var newTag = new Tag
{
Name = request.TagName,
CreatorId = HttpContext.GetUserId(),
CreatedOn = DateTime.Now
};
var created = await _postService.CreateTAgAsync(newTag);
if (!created)
{
return(BadRequest(new ErrorResponse
{
Errors = new List <ErrorModel> {
new ErrorModel {
Message = "Unable to create tag"
}
}
}));
}
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUrl = baseUrl + "/" + ApiRoutes.Tags.Get.Replace("{tagName}", newTag.Name);
return(Created(locationUrl, _mapper.Map <TagResponse>(newTag)));
}
public async Task <IActionResult> Create([FromBody] CreateTagRequest tagRequest)
{
var newTag = new Tag
{
Name = tagRequest.Name,
CreatorId = HttpContext.GetUserId(),
CreatedOn = DateTime.UtcNow
};
var created = await this.postService.CreateTagAsync(newTag);
if (!created)
{
return(BadRequest("Unable to create tag"));
}
var tagResponse = new TagResponse
{
Name = newTag.Name
};
var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUri = baseUrl + "/" + ApiRoutes.Tags.Get.Replace("{tagName}", newTag.Name);
return(Created(locationUri, tagResponse));
}
public async Task <IActionResult> Create([FromBody] CreateTagRequest createTagRequest)
{
//if (!ModelState.IsValid) được thay thể bằng ValidationFilter
//{
// return BadRequest(new { error = "Not validated" });
//}
//class này có validator là: ValadationFilter(Model.IsValid) và CreateTagRequestValidator
var newTag = new Tag
{
TagId = Guid.NewGuid().ToString(),
Name = createTagRequest.TagName,
CreatedOn = DateTime.UtcNow,
CreatorID = HttpContext.GetUserId(),
PostId = Guid.Parse("6F9A8C75-293C-4E7B-A3D3-760A664F4877"),
};
var created = await _postService.CreateTagAsync(newTag);
if (created)
{
return(Ok(newTag));
}
return(BadRequest(new ErrorResponse {
Errors = new List <ErrorModel> {
new ErrorModel {
Message = "Unable to create tag"
}
}
}));
}
public ResponseMessage CreateTag(CreateTagRequest request)
{
var response = new CreateTagRequest();
try
{
if (string.IsNullOrEmpty(request.Name))
{
response.Errors.Add("The name is empty or null");
}
else
{
_context.Tag.Add(new ToDoList.Entities.TagEntity {
Name = request.Name
});
_context.SaveChanges();
}
if (!response.IsOk)
{
return(response);
}
}
catch (Exception msg)
{
response.Errors.Add(msg.Message);
}
if (!response.IsOk)
{
return(response);
}
return(response);
}
public async Task <string> CreateVirtualMachineTagAsync(int vmID, CreateTagRequest req)
{
if (vmID < 1)
{
throw new Client.Exception.UKFastClientValidationException("Invalid virtual machine id");
}
return((await this.Client.PostAsync <Tag>($"/ecloud/v1/vms/{vmID}/tags", req)).Key);
}
/// <summary>
/// </summary>
/// <exception cref="ApiException">Thrown when fails to make API call</exception>
/// <param name="flagID">numeric ID of the flag</param>
/// <param name="body">create a tag</param>
/// <returns>Task of ApiResponse (Tag)</returns>
public async Task <ApiResponse <Tag> > CreateTagAsync(long flagID, CreateTagRequest body)
{
if (body == null)
{
throw new ApiException(400, "Missing required parameter 'body' when calling TagApi->CreateTag");
}
return(await _httpClient.PostAsync($"flags/{flagID}/tags").WithBody((x) => x.Model(body)).AsApiResponse <Tag>());
}
public CreateTest(CustomWebApplicationFactory factory,
ITestOutputHelper output) : base(factory)
{
_faker = new Faker("pt_BR");
_output = output;
_createTagRequest = new CreateTagRequest
{
Name = _faker.Random.String2(8),
};
}
/// <summary>
/// 为指定实例添加标签
/// </summary>
public CreateTagResponse CreateTag(CreateTagRequest createTagRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("resource_type", createTagRequest.ResourceType.ToString());
urlParam.Add("resource_id", createTagRequest.ResourceId.ToString());
string urlPath = HttpUtils.AddUrlPath("/v2/{project_id}/{resource_type}/{resource_id}/tags", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", createTagRequest);
HttpResponseMessage response = DoHttpRequestSync("POST", request);
return(JsonUtils.DeSerializeNull <CreateTagResponse>(response));
}
public void Multiple()
{
var service = new CreateTagService
{
RequestBuilder = ServerRequestBuilder.Instance
};
var request = new CreateTagRequest {
Tag = "tag1"
};
service.Execute(request, response => Debug.WriteLine("Success"), ExceptionHandler.Handle);
}
/// <summary>Snippet for CreateTag</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void CreateTagRequestObject()
{
// Create client
DataCatalogClient dataCatalogClient = DataCatalogClient.Create();
// Initialize request argument(s)
CreateTagRequest request = new CreateTagRequest
{
ParentAsTagName = TagName.FromProjectLocationEntryGroupEntryTag("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]", "[TAG]"),
Tag = new Tag(),
};
// Make the request
Tag response = dataCatalogClient.CreateTag(request);
}
public async Task <IActionResult> Create([FromBody] CreateTagRequest request)
{
var created = await _tagService.CreateTagAsync(request.name);
if (!created)
{
return(BadRequest(new { error = "Unable to create tag" }));
}
//var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
//var locationUri = baseUrl + "/" + ApiRoutes.Tags.Get.Replace("{tagName}", newTag.Name);
return(Ok());
//return Created(locationUri, newTag);
}
public void Tags()
{
var service = new CreateTagService
{
RequestBuilder = RequestBuilderHelper.Build()
};
var asyncTestHelper = new AsyncTestHelper();
var request = new CreateTagRequest {
Tag = "myTag"
};
service.Execute(request, response => asyncTestHelper.Callback(null), asyncTestHelper.HandleException);
asyncTestHelper.Wait();
}
/// <summary>
/// 本接口用于创建一对标签键和标签值
/// </summary>
/// <param name="req"><see cref="CreateTagRequest"/></param>
/// <returns><see cref="CreateTagResponse"/></returns>
public CreateTagResponse CreateTagSync(CreateTagRequest req)
{
JsonResponseModel <CreateTagResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "CreateTag");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <CreateTagResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public async Task <TagResponse> Handle(CreateTagRequest request)
{
if (!Enum.IsDefined(typeof(UserRole), request.Bound.ToUpper()))
{
throw new ArgumentOutOfRangeException("User role has wrong value");
}
var tagBoundToRole = Enum.Parse <UserRole>(request.Bound.ToUpper());
var tag = new Tag(request.Name, tagBoundToRole);
_tagRepository.Create(tag);
await _tagRepository.PersistChanges();
return(tag.Adapt <TagResponse>());
}
public async Task <IActionResult> Create([FromForm, Bind("Name,Bound")] CreateTagViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var createTagRequest = new CreateTagRequest
{
Name = model.Name,
Bound = model.Bound
};
var response = await _tagApplicationService.Handle(createTagRequest);
return(RedirectToAction(nameof(Index)));
}
public async Task CreateVirtualMachineTagAsync_ExpectedResult()
{
CreateTagRequest req = new CreateTagRequest()
{
Key = "testkey",
Value = "testvalue"
};
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
client.PostAsync <Tag>("/ecloud/v1/vms/123/tags", req).Returns(new Tag()
{
Key = "testkey"
});
var ops = new VirtualMachineTagOperations <Tag>(client);
var tagKey = await ops.CreateVirtualMachineTagAsync(123, req);
Assert.AreEqual("testkey", tagKey);
}
public void CreateTag()
{
using (var scope = Global.ServiceProviderRoot.CreateScope())
{
var api = scope.ServiceProvider.GetRequiredService <IRelationApi>();
var cookie = scope.ServiceProvider.GetRequiredService <BiliCookie>();
string referer = string.Format(RelationApiConstant.GetTagsReferer, cookie.UserId);
var request = new CreateTagRequest
{
Tag = "测试",
Csrf = cookie.BiliJct
};
var re = api.CreateTag(request, referer)
.GetAwaiter().GetResult();
Debug.WriteLine(JsonSerializer.Serialize(re));
}
}
public async Task <ServiceResponse <ITag> > CreateTag(CreateTagRequest request)
{
try
{
var item = await _fileSystem.GetFileSystemItem(i => i.Path == request.Path);
if (item == null)
{
throw new Exception($"Path is not found: {request.Path}");
}
var tag = await _fileSystem.CreateTag(request.Path, request.Name, request.Value);
return(new ServiceResponse <ITag>(tag));
}
catch (Exception exception)
{
_logger.LogWarning(exception, $"Could not create Tag: {request.Path} - {request.Name}");
return(new ServiceResponse <ITag>(exception));
}
}
public async Task <IActionResult> CreateTag([FromBody] CreateTagRequest request)
{
// validate input
if (!ModelState.IsValid)
{
return(HttpResult.BadRequest(ModelState));
}
// verify category exists
var category = await _bagsContext
.TagCategories
.Where(x => x.Id == request.CategoryId)
.SingleOrDefaultAsync();
if (category == null)
{
return(HttpResult.BadRequest($"Category {request.CategoryId} does not exist."));
}
// check for existing tag
var existingTag = await _bagsContext.Tags
.WithSafeIncludes()
.Where(tag => tag.Name == request.Name && tag.TagCategoryId == request.CategoryId)
.SingleOrDefaultAsync();
if (existingTag != null)
{
return(HttpResult.Ok(existingTag.ToSafeExpandedWireFormat()));
}
// create a new tag
var newTag = new Models.Tag {
Name = request.Name, TagCategory = category
};
_bagsContext.Tags.Add(newTag);
await _bagsContext.SaveChangesAsync();
return(HttpResult.Ok(newTag.ToSafeExpandedWireFormat()));
}
public async void TestCreate()
{
String accessToken = this.RandomString();
Models.Tag tag = new Models.Tag();
tag.TagData = new Models.TagData();
tag.TagData.Name = this.RandomString();
CreateTagRequest req = new CreateTagRequest();
req.Tag = tag;
MockAPI <Tags> mock = this.MockFor <Tags>(
HttpMethod.Post,
"/api/v1/tags.create",
m => m.WithContent(req.ToString())
.Respond("application/json", req.ToString())
);
APIResponse <TagResponseBody> res = await mock.Instance.Create(accessToken, tag, null);
mock.Handler.VerifyNoOutstandingExpectation();
Assert.Equal(tag.TagData.Name, res.Body.Tag.TagData.Name);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateTagRequest request;
try
{
request = new CreateTagRequest
{
TagNamespaceId = TagNamespaceId,
CreateTagDetails = CreateTagDetails,
OpcRetryToken = OpcRetryToken
};
response = client.CreateTag(request).GetAwaiter().GetResult();
WriteOutput(response, response.Tag);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task <IActionResult> CreateAsync([FromBody] CreateTagRequest model)
{
if (!ModelState.IsValid)
{
return(Bad(ModelState));
}
if (await _tagsService.AnyAsync(new TagSpecification(x => x.Title.ToLower().Equals(model.Title.ToLower()))))
{
return(Bad(ModelState));
}
var tag = _mapper.Map <Tag>(model);
await _tagsService.InsertAsync(tag);
var response = new CreatedResponse <int> {
Id = tag.Id
};
var baseUrl = $@"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}";
var locationUrl = baseUrl + "/" + ApiRoutes.TagsController.GetTag.Replace("{id}", tag.Id.ToString());
return(Created(locationUrl, response));
}
/// <summary>
/// 创建标签
/// 文档：https://work.weixin.qq.com/api/doc#10915
/// </summary>
/// <param name="tag">标签信息</param>
/// <returns>返回结果</returns>
public CreateTagResult Create(CreateTagRequest tag)
{
var accessToken = Client.GetToken();
return(Client.PostAsJson <CreateTagResult>("/tag/create", new { accessToken.access_token }, tag));
}
/// <summary>
/// Create new tag
/// </summary>
/// <param name="projectId">The ID, path or <see cref="Project"/> of the project.</param>
/// <param name="request">Create Tag request.</param>
/// <returns>newly created Tag</returns>
public async Task <Tag> CreateAsync(ProjectId projectId, CreateTagRequest request) =>
await _httpFacade.Post <Tag>($"projects/{projectId}/repository/tags", request);
public async Task <IActionResult> Create([FromBody] CreateTagRequest request, CancellationToken cancellationToken = default)
{
return(Ok(await Mediator.Send(request, cancellationToken)));
}
