private async Task <List <ImageTagEntity> > SaveTagsAsync(string tagsString)
{
var savedTags = new List <ImageTagEntity>();
if (string.IsNullOrEmpty(tagsString))
{
return(savedTags);
}
var tags = tagsString.Split(' ', StringSplitOptions.RemoveEmptyEntries);
foreach (var tag in tags)
{
var tagEntity = new TagEntity
{
Name = tag
};
TagEntity savedTag = await tagRepository.AddAsync(tagEntity);
savedTags.Add(new ImageTagEntity
{
TagId = savedTag.Id
});
}
return(savedTags);
}
private async Task InitTagRepository()
{
foreach (var tag in Tags)
{
await tagRepository.AddAsync(tag);
}
}
public async Task <int> Handle(CreateTagCommand request, CancellationToken cancellationToken)
{
Tag tagToInsert = new Tag(request.DisplayName);
await _tagRepository.AddAsync(tagToInsert);
await _tagRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
return(tagToInsert.Id);
}
public Task <Tag> AddAsync(Tag tag,
CancellationToken cancel)
{
return(_tagRepository.AddAsync(tag, cancel)
.ContinueWith(task =>
{
_memoryCache.Remove(TopTagsKey);
return task.Result;
},
cancel));
}
public async Task <Tag> CreateTagAsync(Tag tag,
CancellationToken cancel = default)
{
if (tag == null)
{
throw new ArgumentException(nameof(tag));
}
await _tagRepository.AddAsync(tag, cancel);
return(tag);
}
public async Task <IResultModel> Add(TagAddModel model)
{
var entity = _mapper.Map <TagEntity>(model);
//if (await _repository.Exists(entity))
//{
//return ResultModel.HasExists;
//}
var result = await _repository.AddAsync(entity);
return(ResultModel.Result(result));
}
public async Task <TagResponse> SaveAsync(Tag tag)
{
try{
await tagRepository.AddAsync(tag);
await unitOfWork.CompleteAsync();
return(new TagResponse(tag));
}
catch (Exception ex) {
return(new TagResponse($"Error while saving tag! Message:{ex.Message}"));
}
}
public async Task <TagDto> AddAsync(TagCreateDto dto)
{
if (string.IsNullOrEmpty(dto.Name))
{
throw new ArticleException(ArticleErrorCodes.TagNameCannotBeNull, "Tag Name field is mandatory.", dto);
}
var entity = dto.Adapt <Domain.Tag>();
entity = await _tagRepository.AddAsync(entity);
return(entity.Adapt <TagDto>());
}
/// <summary>
/// 指定した既存データIDとタグを関連付ける。
/// 既存の関連付け状況に関わらず、指定されたタグのみが紐づいている状況にする（他の紐づけはすべて削除する）
/// </summary>
/// <remarks>
/// 親無しになるタグのチェックは行わない。
/// </remarks>
public async Task EditAsync(long dataId, IEnumerable <string> inputTags)
{
//まずは既存のタグをすべて削除
tagRepository.DeleteAll(dataId);
foreach (var inputTag in inputTags.Distinct())
{
if (string.IsNullOrEmpty(inputTag) == false)
{
//タグを付与する。既存タグは削除済みなので、重複チェックはしない。
await tagRepository.AddAsync(dataId, inputTag, false);
}
}
}
public async Task <SaveTagResponse> SaveAsync(Tag tag)
{
try
{
await _tagRepository.AddAsync(tag);
return(new SaveTagResponse(tag));
}
catch (Exception ex)
{
// Do some logging stuff
return(new SaveTagResponse($"An error occurred when saving the category: {ex.Message}"));
}
}
public async Task <Guid> Handle(AddTagRequest request, CancellationToken cancellationToken)
{
if (await repository.NameExistAsync(request.Name, cancellationToken))
{
throw new TagNameAlreadyExistException(request.Name);
}
Guid Id = repository.NextIdentifier();
await repository.AddAsync(new Tag {
Id = Id,
Name = request.Name
}, cancellationToken);
return(Id);
}
public async Task <TagResponse> SaveAsync(Tag tag)
{
try
{
await _tagRepository.AddAsync(tag);
await _unitOfWork.CompleteAsync();
return(new TagResponse(tag));
}
catch (Exception e)
{
return(new TagResponse($"An error ocurred while saving the tag {e.Message}"));
}
}
public async Task <TagCreated> Handle(CreateTagCommand request, CancellationToken cancellationToken)
{
var tag = new Tag
{
Id = 0,
Name = request.Name
};
await _tagRepository.AddAsync(tag);
await _unitOfWork.CompleteAsync(cancellationToken);
return(new TagCreated {
Id = tag.Id
});
}
public async Task <IActionResult> AttachTag(long id, string tag, [FromServices] ITagRepository tagRepository)
{
//データの存在チェック
var data = await dataRepository.GetByIdAsync(id);
if (data == null)
{
return(JsonNotFound($"Data ID {id} is not found."));
}
await tagRepository.AddAsync(data.Id, tag);
//結果を取り直す
var result = await dataRepository.GetDataIncludeAllAsync(data.Id);
return(JsonOK(new DetailsOutputModel(result)));
}
public async Task <BaseResponse> AddAsync(AddTagRequest request, int accountId)
{
var loggedUser = await _authenticationService.GetLoggedUserAsync();
var accountUser = await _accountUserRepository.GetAsync(accountUser => accountUser.UserId == loggedUser.User.Id && accountUser.AccountId == accountId);
var tag = _mapper.Map <AddTagRequest, Tag>(request);
tag.CreatedBy = accountUser;
tag.AccountId = accountId;
await _tagRepository.AddAsync(tag);
await _unitOfWork.SaveChangesAsync();
return(new BaseResponse());
}
public async Task <ICollection <Tag> > AddOrUpdateTags(string[] tags)
{
var tagEntities = new List <Tag>();
foreach (var tag in tags)
{
var tagEntity = await _tagRepository.Query().FirstOrDefaultAsync(x => x.Content == tag);
if (tagEntity == null)
{
tagEntity = await _tagRepository.AddAsync(new Tag()
{
Content = tag
});
}
}
await _tagRepository.CommitAsync();
tagEntities = tags.Select(x => _tagRepository.Query().FirstOrDefault(y => y.Content == x)).ToList();
return(tagEntities);
}
public async Task <IActionResult> Save(int?id, string title, State state)
{
if (id == null)
{
//Todo: Add
await _tagRepo.AddAsync(new Tag
{
Creator = Operator,
CreateDate = DateTime.UtcNow,
Title = title,
State = state
});
await _tagRepo.SaveAsync();
return(RedirectToAction("list"));
}
else
{
//Tdod: Edit
var editModel = await _tagRepo.GetTagAsync(id.Value);
editModel.Title = title;
editModel.State = state;
editModel.LastModifier = Operator;
editModel.LastModifyDate = DateTime.UtcNow;
_tagRepo.Update(editModel);
await _tagRepo.SaveAsync();
return(RedirectToAction("List"));
}
return(RedirectToAction("list"));
}
public async Task UpdatePostAsync(UpdatePostModel updatePostModel)
{
ArgumentGuard.NotNull(updatePostModel, nameof(updatePostModel));
ArgumentGuard.NotEmpty(updatePostModel.Id, nameof(updatePostModel.Id));
await _validatorfactory.ValidateAsync(updatePostModel);
var postEntity = await _postRepository.GetPostAsync(updatePostModel.Id);
postEntity.Title = updatePostModel.Title;
postEntity.Status = updatePostModel.Status;
postEntity.Content = updatePostModel.Content;
postEntity.LastModfiedById = _userContext.UserId;
postEntity.LastModifiedDateUtc = DateTime.UtcNow;
_tagRepository.RemoveTagsAsync(postEntity.Tags);
foreach (var tag in updatePostModel.Tags)
{
await _tagRepository.AddAsync(new TagEntity { Id = Guid.NewGuid(), Name = tag, PostId = updatePostModel.Id });
}
await _postRepository.SaveChangesAsync();
}
public async Task CreateAsync(string tagName)
{
var tag = new TextTag(tagName);
await tagRepository.AddAsync(tag);
}
public bool AddTag(Tag tag, bool isCommit)
{
return(_tag.AddAsync(tag, isCommit).Result);
}
