public async Task <Post> Create(CreatePostDto dto) { User user = await _sessionService.GetUser(); Validate("create", dto.Content, dto.Title, user); var post = new Post { Title = dto.Title, Content = dto.Content, CreationTime = DateTime.Now, LastUpdateTime = DateTime.Now, AuthorId = user.Id, Likes = 0, Dislikes = 0, Tags = TagHelpers.GetTagsFromText(dto.Content), Id = Guid.NewGuid().ToString() }; await _postRepository.Create(post); _logger.LogInformation($"Post {post.Id} has been created"); await _tagRepository.Create(post.Tags.Select(x => new Tag { Name = x, PostsNumber = 1 }).ToArray()); _logger.LogInformation("Tags have been added"); return(post); }
public void AddingTagWithSameName_NoDuplicate() { using (var context = new SpacedRepAppDbContext(_options)) { tagRepositoryToTest = new TagRepository(context, _cacheServiceMock.Object); tagRepositoryToTest.Create(new Tag() { Name = "testTag" }); tagRepositoryToTest.Create(new Tag() { Name = "testTag" }); tagRepositoryToTest.Create(new Tag() { Name = "One More Tag" }); tagRepositoryToTest.Create(new Tag() { Name = "Another Tag" }); var tagCount = tagRepositoryToTest.GetAll().Result.Count; Assert.AreEqual(3, tagCount); } }
/// <inheritdoc/> public Project CreateProject(ProjectCreateDto dto) { var now = DateUtil.Now; var entity = new ProjectTableEntity { ProjectId = Guid.NewGuid(), ProjectCode = dto.ProjectCode, Name = dto.Name, Description = dto.Description, Status = dto.Status, SortNo = dto.SortNo, CreateTime = now, UpdateTime = now, }; using (var tran = new TransactionScope()) { _projectRepository.Create(entity); foreach (var tag in dto.Tags) { _tagRepository.Create(new TagTableEntity { TagId = Guid.NewGuid(), TargetId = entity.ProjectId, Value = tag, TargetTable = "Project", CreateTime = now, }); } tran.Complete(); } return(_projectQueryService.GetProject(entity.ProjectId)); }
public IActionResult Create([FromBody] Tag tag) { var lang = Request.Headers["language"].ToString(); var errorMessages = new List <string>(); try { var newTag = new Tag() { Name = tag.Name }; var createdTag = _tagRepository.Create(newTag); if (createdTag == null) { errorMessages.Add("Error creating tag"); return(BadRequest(new { errors = errorMessages })); } return(Ok(new { createdTag })); } catch { errorMessages.Add(_translator.GetTranslation("ERROR", lang)); return(BadRequest(new { errors = errorMessages })); } }
public EntityAction Create(Tag entity) { entity.Id = rep.GetNextId(); EntityAction result = rep.Create(entity); return(result); }
private ICollection <Tag> TagStringToTags(string tagString) { IEnumerable <string> splitList = tagString.Split(' ').Distinct().ToList(); ((List <string>)(splitList)).RemoveAll(p => p == " "); ICollection <Tag> tags = new List <Tag>(); foreach (var item in splitList) { var currentTag = tagRepository.CheckExist(item); if (currentTag == null) { Tag tag = new Tag { Name = item }; tagRepository.Create(tag); tags.Add(tag); } else { tags.Add(currentTag); } } tagRepository.Save(); return(tags); }
private void AddNewTags(BlogManagementEditModel model, BlogEntry dbModel, string[] currentTags) { foreach (var tagName in currentTags) { var tagKey = tagName.UrlKey(); if (string.IsNullOrWhiteSpace(tagKey)) { continue; } if (dbModel.BlogEntryTags.FirstOrDefault(x => x.Tag.Key == tagKey) == null) { var tagDb = _tagRepository.Get(tagKey); if (tagDb == null || tagDb.TagId == 0) { _tagRepository.Create(new Tag { Name = tagName.Trim(), Key = tagKey }); tagDb = _tagRepository.Get(tagKey); } _blogEntryTagRepository.Create(new BlogEntryTag() { BlogEntryId = model.BlogEntryId, TagId = tagDb.TagId, }); } } }
public int Create(TagRequest request) { var entity = Mapper.Map <TagRequest, TagEntity>(request); _repository.Create(entity); _repository.SaveChanges(); return(entity.Id); }
public IActionResult Add([FromBody] AddNewsViewModel newsItem) { if (newsItem == null) { return(BadRequest("News is null")); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } newsItem.News.CreatedDate = DateTime.Now; newsItem.News.UpdatedDate = DateTime.Now; if (newsItem.News.Category?.Id != null) { Category c = _categoryRepository.GetById((int)newsItem.News.Category.Id); newsItem.News.Category = c; } // Förhindra att ny kategori skapas om ingen anges if (newsItem.News.Category?.Id == null) { newsItem.News.Category = null; } //creates all tags and the connection between tags and news News thisNews = _newsRepository.Add(newsItem.News); foreach (var tag in newsItem.Tags) { if (tag.Id == 0) { var newTag = _tagRepository.Create(tag); var tagConnection = new NewsTag { News = thisNews, NewsId = thisNews.Id, Tag = newTag, TagId = newTag.Id }; thisNews.NewsTags.Add(tagConnection); } else { var alreadyAddedTag = _tagRepository.GetById(tag.Id); var tagConnection = new NewsTag { News = thisNews, NewsId = thisNews.Id, Tag = alreadyAddedTag }; thisNews.NewsTags.Add(tagConnection); } } //updates the news to add the connection between tags and this news _newsRepository.Update(thisNews); return(Ok()); }
public async Task <bool> Create(TagCreateDto created) { if (created == null) { throw new ArgumentException("Created Tag cannot be null"); } return(await _repository.Create(_mapper.Map <Models.Models.Tag>(created))); }
/// <summary> /// Add new tag to database. /// </summary> /// <param name="tag"></param> public void Add(TagEntity tag) { if (tag == null) { throw new ArgumentNullException(nameof(tag)); } tagRepository.Create(tag.ToDalTag()); uow.Commit(); }
private void SaveTags(Post post) { if (!string.IsNullOrEmpty(post.Tags)) { foreach (var tag in post.TagsList) { tagsRepository.Create(tag); } } }
public ActionResult <Tag> PostTag([FromBody] Tag tag) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } tagRepository.Create(tag); return(tag); }
public async Task Add(Tag entity) { await Task.Run(() => { IUnitOfWork uow = this._uowProvider.Get(); ITagRepository repo = this._repoProvider.Get(uow); repo.Create(entity); uow.Dispose(); }); }
public void Create(TagEntity tag) { if (ReferenceEquals(tag, null)) { throw new ArgumentNullException(nameof(tag)); } repository.Create(tag.ToDalTag()); uow.Commit(); }
public async Task <Guid> Create(string name) { var tag = new Tag { Name = name, IsDeleted = false }; await _tagRepository.Create(tag); await _context.SaveChangesAsync(); return(tag.Id); }
public async Task <IActionResult> Post([FromBody] TagDto newTag) { var tag = new Tag { Id = newTag.Id, Name = newTag.Name, }; var created = await _tagRepository.Create(tag); return(CreatedAtAction(nameof(this.Get), new { id = created.Id }, created)); }
public bool Post([FromBody] Tag newTag, int reviewId) { newTag.ReviewTags = new List <ReviewTag>() { new ReviewTag() { ReviewId = reviewId } }; tagsRepo.Create(newTag); return(true); }
public void Articles_Data_Tag_Insert_Test() { var model = new Tag(name: "Test"); model.Id = rep.GetNextId(); uni.BeginTransAction(); EntityAction result = rep.Create(model); Assert.AreEqual(result, EntityAction.Added); uni.RollBack(); }
public async Task UpdateTags(ItemTagsDto dto) { await Task.Run(() => { // begin transaction IUnitOfWork uow = this._uowProvider.Get(); IMediaItemRepository itemRepo = this._repoProvider.Get(uow); ITagRepository tagRepo = this._tagRepoProvider.Get(uow); uow.Begin(); // add tags foreach (var tag in dto.TagsToAdd) { if (tagRepo.ExistsWithName(tag)) { // tag exists // get the Id int tagId = tagRepo.GetIdByName(tag); // insert record into link table tagRepo.LinkMediaItem(dto.Id, tagId); } else { // tag does not exist // insert it tagRepo.Create(new Tag { Name = tag }); // get the id int tagId = tagRepo.GetIdByName(tag); // insert record into link table tagRepo.LinkMediaItem(dto.Id, tagId); } } // remove tags foreach (var tag in dto.TagsToRemove) { if (tagRepo.ExistsWithName(tag)) { // tag exists // get the id int tagId = tagRepo.GetIdByName(tag); // delete record from link table tagRepo.UnlinkMediaItem(dto.Id, tagId); } } // commit transaction uow.Commit(); }); }
public bool Insert(Tag tag, int userId) { try { _tagRepository.Create(tag); _routingService.Insert(Common.RoutingType.Tag, userId, tag: tag); return(true); } catch (Exception) { return(false); } }
public void EnsureTag(TagDTO tag) { var tagEntity = _mapper.Map <TagDTO, Tag>(tag); if (tagEntity.Id > 0) { _tagRepository.Update(tagEntity); } else { _tagRepository.Create(tagEntity); } }
/// <inheritdoc/> public Person CreatePerson(PersonCreateDto dto) { var now = DateUtil.Now; var entity = new PersonTableEntity { PersonId = Guid.NewGuid(), PersonCode = dto.PersonCode, LoginId = dto.LoginId, Name = dto.Name, Title = dto.Title, Description = dto.Description, Status = dto.Status, SortNo = dto.SortNo, CreateTime = now, UpdateTime = now, }; using (var tran = new TransactionScope()) { _personRepository.Create(entity); foreach (var tag in dto.Tags) { _tagRepository.Create(new TagTableEntity { TagId = Guid.NewGuid(), TargetId = entity.PersonId, Value = tag, TargetTable = "Person", CreateTime = now, }); } tran.Complete(); } return(_personQueryService.GetPerson(entity.PersonId)); }
/// <inheritdoc/> public WorkType CreateWorkType(WorkTypeCreateDto dto) { var now = DateUtil.Now; var entity = new WorkTypeTableEntity { WorkTypeId = Guid.NewGuid(), WorkTypeCode = dto.WorkTypeCode, WorkTypeTree = dto.WorkTypeTree, Name = dto.Name, Description = dto.Description, Status = dto.Status, SortNo = dto.SortNo, CreateTime = now, UpdateTime = now, }; using (var tran = new TransactionScope()) { _workTypeRepository.Create(entity); foreach (var tag in dto.Tags) { _tagRepository.Create(new TagTableEntity { TagId = Guid.NewGuid(), TargetId = entity.WorkTypeId, Value = tag, TargetTable = "WorkType", CreateTime = now, }); } tran.Complete(); } return(_workTypeQueryService.GetWorkType(entity.WorkTypeId)); }
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>()); }
/// <inheritdoc/> public Group CreateGroup(GroupCreateDto dto) { var now = DateUtil.Now; var entity = new GroupTableEntity { GroupId = Guid.NewGuid(), GroupCode = dto.GroupCode, GroupTree = dto.GroupTree, Name = dto.Name, Description = dto.Description, Status = dto.Status, SortNo = dto.SortNo, CreateTime = now, UpdateTime = now, }; using (var tran = new TransactionScope()) { _groupRepository.Create(entity); foreach (var tag in dto.Tags) { _tagRepository.Create(new TagTableEntity { TagId = Guid.NewGuid(), TargetId = entity.GroupId, Value = tag, TargetTable = "Group", CreateTime = now, }); } tran.Complete(); } return(_groupQueryService.GetGroup(entity.GroupId)); }
public ActionResult <ViewModels.Tag> Create(ViewModels.Tag viewModel) { try { var dataModel = _mapper.Map <DataModels.Tag>(viewModel); dataModel = _repository.Create(dataModel); viewModel = _mapper.Map <ViewModels.Tag>(dataModel); return(viewModel); } catch (Exception ex) { var messageResponse = _errorGenerator.GetMessageResponse <DataModels.Tag, ViewModels.Tag>(ActionType.Create, viewModel, exception: ex); Log.Error(messageResponse.LogTemplate, messageResponse.Message, viewModel); throw new Exception(messageResponse.Message); } }
private async Task FixTagsOnEdit(Note noteToFix, Note newNote) { foreach (var tag in newNote.Tags) { if (!noteToFix.Tags.Any(x => x.Name == tag.Name)) { await _tagRepository.Create(tag); } } _context.Entry(noteToFix).Entity.Tags.Clear(); _context.Entry(noteToFix).Entity.Tags.AddRange(newNote.Tags); _context.Entry(noteToFix).CurrentValues.SetValues(newNote); _context.Entry(noteToFix).State = EntityState.Modified; await _context.SaveChangesAsync(); }
public async Task Add(MediaItem item) { await Task.Run(() => { // begin transaction IUnitOfWork uow = this._uowProvider.Get(); IMediaItemRepository itemRepo = this._repoProvider.Get(uow); ITagRepository tagRepo = this._tagRepoProvider.Get(uow); uow.Begin(); // insert Media table record itemRepo.Create(item); // handle tags // get all tag Ids List <int> tagIds = new List <int>(); foreach (var tag in item.Tags) { if (tagRepo.ExistsWithName(tag.Name)) { // tag exists // get the Id int tagId = tagRepo.GetIdByName(tag.Name); tagIds.Add(tagId); } else { // tag does not exist // insert tag tagRepo.Create(tag); // get the Id int tagId = tagRepo.GetIdByName(tag.Name); tagIds.Add(tagId); } } // insert record(s) in Media_Tag link table int itemId = itemRepo.GetIdByTitle(item.Title); foreach (int tagId in tagIds) { tagRepo.LinkMediaItem(itemId, tagId); } // commit transaction uow.Commit(); }); }
public async Task <IActionResult> Create([Bind("Text")] Tag tag) { if (!ModelState.IsValid) { return(View(tag)); } if (string.IsNullOrWhiteSpace(tag.Text)) { ModelState.AddModelError("Text", "Tag text can't be empty"); return(View(tag)); } await _tagRepository.Create(tag); return(RedirectToAction(nameof(Index))); }