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