public async Task <IActionResult> PutTag(int id, TagRequest Tag)
{
if (Tag == null || id != Tag.Id)
{
return(BadRequest());
}
(int ResultAction, TagResponse UpdatedEntity)result = (-1, null);
try
{
result = await _tagServices.UpdateTagAsync(id, Tag);
}
catch (DbUpdateConcurrencyException)
{
if (!TagExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(result.UpdatedEntity));
//return NoContent();
}
public ActionResult <Tag> Delete(TagRequest tagRequest, Guid documentId)
{
var userId = (this.HttpContext.Items["User"] as EntityUser).Id;
var tag = this._tagService.Add(documentId, tagRequest, userId);
return(Ok(tag));
}
public async Task Should_Return_Ok_When_Update()
{
//Arrange
var tag = new TagRequest();
var tagDTO = new TagDTO();
var cancellationToken = new CancellationToken();
var addService = new Mock <IAdminAddService>();
var updateService = new Mock <IAdminUpdateService>();
var deleteService = new Mock <IAdminDeleteService>();
var logger = new Mock <ILogger <AdminController> >();
var mapper = new Mock <IMapper>();
mapper.Setup(m => m.Map <TagDTO>(tag)).Returns(tagDTO);
updateService.Setup(u => u.UpdateTag(tagDTO, cancellationToken));
var controller = new AdminController(addService.Object, updateService.Object, deleteService.Object,
logger.Object, mapper.Object);
//Act
var result = await controller.UpdateTag(tag, cancellationToken);
//Assert
mapper.Verify(m => m.Map <TagDTO>(tag), Times.Once);
updateService.Verify(u => u.UpdateTag(tagDTO, cancellationToken));
Assert.IsType <OkResult>(result);
}
internal virtual TagResponse Tag(TagRequest request)
{
var marshaller = TagRequestMarshaller.Instance;
var unmarshaller = TagResponseUnmarshaller.Instance;
return(Invoke <TagRequest, TagResponse>(request, marshaller, unmarshaller));
}
public static async Task <IActionResult> CheckTags(
[HttpTrigger(AuthorizationLevel.Function, "post")] TagRequest req,
[CosmosDB("ignite", "tags", Id = "{ResourceGroup}", ConnectionStringSetting = "CosmosDBConnectionString")] Document doc,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
JObject cosmosTags = doc.GetPropertyValue <JObject>("tags");
log.LogInformation("Exected tags: " + cosmosTags.ToString());
log.LogInformation("Actual tags: " + req.Tags.ToString());
bool equal = true;
foreach (var tag in cosmosTags)
{
if (!(req.Tags.ContainsKey(tag.Key) && ((string)req.Tags.GetValue(tag.Key)).Equals((string)tag.Value)))
{
equal = false;
}
}
return(new OkObjectResult(
new {
isEqual = equal,
expected = cosmosTags,
actual = req.Tags
}));
}
public async Task <ActionResult <Account> > AddTagAsync(int id, [FromBody] TagRequest tag)
{
IAccountService accountService = RepositoryServiceProvider.AccountService;
await accountService.AddTagAsync(id, tag.Tag, tag.Description);
return(Ok(await accountService.GetAccountAsync(id, 0)));
}
public TagResponse UnTagObjects(string app, TagRequest req)
{
using (var context = ResolveContext())
{
var business = context.GetBusinessManager().GetTaggingBusiness();
return(business.ManageTagObjects(app, req, false));
}
}
public async Task Add(TagRequest request)
{
Tag tag = Tag.Create(tagName: request.TagName);
tag.AddMediaItem(request.PictureId, globalIndex: request.PictureIndex);
await _tagRepository.Save(tag);
}
/// <summary>
/// Initiates the asynchronous execution of the Tag operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Tag operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/resource-groups-2017-11-27/Tag">REST API Reference for Tag Operation</seealso>
public virtual Task <TagResponse> TagAsync(TagRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = TagRequestMarshaller.Instance;
var unmarshaller = TagResponseUnmarshaller.Instance;
return(InvokeAsync <TagRequest, TagResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public async Task <ActionResult> CreateTag([FromBody] TagRequest tagDto)
{
var tag = _mapper.Map <Tag>(tagDto);
await _unitOfWork.Tags.CreateAsync(tag);
await _unitOfWork.CommitAsync();
return(NoContent());
}
/// <summary>
/// Initiates the asynchronous execution of the Tag operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the Tag operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/resource-groups-2017-11-27/Tag">REST API Reference for Tag Operation</seealso>
public virtual Task <TagResponse> TagAsync(TagRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = TagRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResponseUnmarshaller.Instance;
return(InvokeAsync <TagResponse>(request, options, cancellationToken));
}
internal virtual TagResponse Tag(TagRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = TagRequestMarshaller.Instance;
options.ResponseUnmarshaller = TagResponseUnmarshaller.Instance;
return(Invoke <TagResponse>(request, options));
}
/// <summary>
/// Remove tag from trace.
/// </summary>
/// <param name="organizationId">Organization UUID.</param>
/// <param name="traceUuid">Trace UUID.</param>
/// <param name="tag">The tag to be deleted.</param>
/// <returns>A TagsResponse object which indicates wheter the operation was successful or not.</returns>
public TagsResponse DeleteTraceTag(string organizationId, string traceUuid, string tag)
{
string endpoint = String.Format(NgEndpoints.DELETE_TRACE_TAG, organizationId, traceUuid);
TagRequest request = new TagRequest();
request.Tag = tag;
return(GetResponseAndDeserialize <TagsResponse>(endpoint, JsonConvert.SerializeObject(request), RequestMethod.Delete));
}
public async Task <IActionResult> UpdateTag(
[FromBody] TagRequest tag,
CancellationToken cancellationToken)
{
var tagDTO = _mapper.Map <TagDTO>(tag);
await _adminUpdateService.UpdateTag(tagDTO, cancellationToken);
return(Ok());
}
public async Task <ActionResult> PostTag(TagRequest Tag)
{
var addedTag = await _tagServices.AddTagAsync(Tag);
//_context.Tags.Add(Tag);
//await _context.SaveChangesAsync();
return(CreatedAtAction("Tags-{name}-{id}", new { name = addedTag.AddedEntity.Name, id = addedTag.AddedEntity.TagID }, addedTag.AddedEntity));
}
public async Task CreateTagAsync_NullName_ShouldThrowArgumentException()
{
var tagRequest = new TagRequest {
Name = null,
};
Func <Task> create = () => _client.CreateTagAsync(_workspaceId, tagRequest);
await create.Should().ThrowAsync <ArgumentException>()
.WithMessage($"Argument cannot be null. (Parameter '{nameof(TagRequest.Name)}')");
}
private Tag MapRequestToTag(TagRequest request)
{
return(new Tag
{
Id = request.Id,
Location = request.Location,
Content = request.Content,
TimePosted = request.TimePosted
});
}
public IActionResult AddTag([FromBody] TagRequest tagRequest)
{
var tag = _mapper.Map <Tag>(tagRequest);
_tagManager.AddTag(tag);
var response = _mapper.Map <TagResponse>(tag);
return(CreatedAtAction(nameof(GetTag), new { id = tag.Id }, response));
}
private Tag MapRequestToTag(TagRequest request, string userEmail)
{
return(new Tag
{
Id = request.Id,
UserEmail = userEmail,
Location = request.Location,
Content = request.Content,
TimePosted = request.TimePosted
});
}
/// <summary>
/// Adds a tag
/// </summary>
/// <param name="tagRequest"></param>
/// <returns></returns>
public async Task <string> AddTag(TagRequest tagRequest)
{
tagRequest.Tag.Id = Guid.NewGuid().ToString();
var path = "Tags/" + tagRequest.Auth["uid"] + "/" + tagRequest.Tag.Id;
var json = JsonSerializer.Serialize(tagRequest.Tag);
var response = await _dataService.ApiGoogle("PUT", json, path, tagRequest.Auth);
var tag = _helper.Mapper <Link>(response);
return(tag.Id);
}
// TODO: Update to return deleted tag
public void DeleteTag(TagRequest request)
{
if (TokenIsAdmin(request.Token))
{
// Create tag
var tag = MapRequestToTag(request);
_context.Tags.Remove(tag);
_context.SaveChanges();
}
}
/// <summary>
/// Add a new client to workspace.
/// </summary>
public Task <IRestResponse <TagDto> > CreateTagAsync(string workspaceId, TagRequest projectRequest)
{
if (projectRequest == null)
{
throw new ArgumentNullException(nameof(projectRequest));
}
Require.Argument(nameof(projectRequest.Name), projectRequest.Name);
var request = new RestRequest($"workspaces/{workspaceId}/tags", Method.POST);
request.AddJsonBody(projectRequest);
return(_client.ExecutePostTaskAsync <TagDto>(request));
}
public IActionResult CreateTag([FromBody] TagRequest request)
{
try {
var id = _tagRepository.CreateTag(request);
return(Ok(id));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IActionResult> AddLike(string id)
{
var request = new TagRequest
{
PictureId = id,
TagName = "like",
};
await _tagService.Add(request);
return(Ok());
}
public async Task <IActionResult> AddTag(AddTagAjaxRequest data)
{
var request = new TagRequest
{
PictureId = data.PictureId,
TagName = data.Tag
};
await _tagService.Add(request);
return(Ok());
}
// Search Tags
public void TagsTenorGIF()
{
// Initialize SDK
TenorAPI.Initialize("LIVDSRZULELA");
// Prepare Request data
TagRequest request = new TagRequest();
request.type = "featured";
// Call Coroutine to not freeze
StartCoroutine(TenorAPI.Tags(request, ProcessAnswers));
}
public TagResponse Post([FromBody] TagRequest request)
{
return(new TagResponse
{
Offers = Enumerable.Range(0, 20).Select(i =>
new TagOffer
{
Name = "Offer" + i,
Description = "Description of Offer" + 1,
Price = i % 3 == 0 ? "$12" : "$20",
}).ToList()
});
}
public async Task SendTagsAsync(IEnumerable <Tag> tags)
{
if (!tags.Any())
{
return;
}
var content = new TagRequest();
content.metadata = tags.ToArray();
await _httpClient.PostAsync("https://online.wonderware.com/apis/upload/datasource", new StringContent(JsonConvert.SerializeObject(content), Encoding.UTF8, "application/json"));
}
private bool VerifyTokenMatchesPreviousTag(User user, TagRequest request)
{
var previousTag = _context.Tags
.AsNoTracking()
.Include(_ => _.User)
.FirstOrDefault(_ => _.Id == request.Id);
if (previousTag == null)
{
throw new KeyNotFoundException(request.Id.ToString());
}
return(user.Email == previousTag.User.Email);
}
public IActionResult getTagValues([FromBody] TagRequest rq)
{
List <dynamic> listUnit = new List <dynamic>();
List <Unit> listCenter = m_organization.getAllTTVT();
List <Unit> lstUnit = m_organization.getAllDoiVT();
var tt_id = listCenter.FirstOrDefault(center => center.ten_dv == rq.key).donvi_id;
List <Unit> result = lstUnit.FindAll(unit => unit.donvi_cha_id == tt_id);
foreach (var row in result)
{
listUnit.Add(new { text = row.ten_dv });
}
return(Ok(listUnit));
}
public IEnumerable<Tag> GetTagList(TagRequest request = null)
{
request = request ?? new TagRequest();
using (var dbContext = new CmsDbContext())
{
IQueryable<Tag> tags = dbContext.Tags;
if (request.Orderby == Orderby.Hits)
return tags.OrderByDescending(u => u.Hits).ToPagedList(request.PageIndex, request.PageSize);
else
return tags.OrderByDescending(u => u.ID).ToPagedList(request.PageIndex, request.PageSize);
}
}
