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); } }