public void GetTagsByTagNameAndDate_GetsTagDto_WhenArticlesExistForTagAndDate()
{
using (var ctx = ContextUtil.GetContext())
{
var tags = new string[]
{
"Health", "Science", "Fitness",
"Crime", "Cars", "Driving", "Fruitarian", "See Food Diet", "Lifestyle"
};
var articles = GetArticleData(tags.ToList());
foreach (var article in articles)
{
ctx.Articles.Add(article);
ctx.SaveChanges(true);
}
var repo = new TagsRepository(ctx);
var result = repo.GetTagsByTagNameAndDate("Health", DateTime.UtcNow).GetAwaiter().GetResult();
Assert.AreEqual("Health", result.Tag);
// The count field shows the number of tags for the tag for that day.
Assert.AreEqual(7, result.Count);
// count of unique tags related to health
CollectionAssert.AreEquivalent(
new string[] { "Science", "Fitness", "Fruitarian", "See Food Diet" }, result.RelatedTags.ToArray());
// The articles field contains a list of ids for the last 10 articles entered for that day.
Assert.AreEqual(3, result.Articles.Length);
}
}
public void Post([FromBody] CreateImageCommand request)
{
var repository = new ImagesRepository();
var tagRepository = new TagsRepository();
var tags = new List <ImorTag>();
foreach (var tag in request.Tags)
{
var existingTag = tagRepository.GetTagByUri(tag);
if (existingTag != null)
{
tags.Add(existingTag);
}
}
repository.InsertImage(new ImorImage
{
Uri = request.Uri,
Description = request.Description,
Content = request.Content,
Tags = tags
});
}
public PostsSearchProvider(ILogger <PostsSearchProvider <TUserPk> > logger,
TagsRepository tagsRepository, PostsRepository <TUserPk> postsRepository,
ISearcher searcher = null) : base(logger, searcher)
{
_tagsRepository = tagsRepository;
_postsRepository = postsRepository;
}
public UnitofWork(ApplicationDbContext dbContext)
{
applicationDbContext = dbContext;
Questions = new QuestionsRepository(applicationDbContext);
Tags = new TagsRepository(applicationDbContext);
Answers = new AnswersRepository(applicationDbContext);
}
public void Can_Get_All_Tags_From_Repository()
{
TagsRepository repository = new TagsRepository(ConfigurationManager.ConnectionStrings["TaskTracker"].ConnectionString);
var allTags = repository.GetAll();
Assert.That(allTags, Has.Count.GreaterThan(0));
}
private void ImportTagsTranslate(TagsRepository tagsRepository)
{
DataTable tableTagsTranslate = this.GetTableTagsValuesTrans();
TagCompleteRowEnumerator enumerator = tagsRepository.GetEnumerator();
while (enumerator.MoveNext())
{
TagCompleteRow tagCompleteRow = enumerator.Current;
DataRow row = tableTagsTranslate.NewRow();
row["tagHash"] = tagCompleteRow.KeyId;
if (tagCompleteRow.TypeValue == TypeValueTag.Id)
{
row["typeTrans"] = TagValueTransType.TagAndValue;
row["valueHash"] = tagCompleteRow.ValueId;
row["valTrans"] = tagCompleteRow.ValueName;
}
else
{
row["valueHash"] = Int32.MaxValue;
row["typeTrans"] = TagValueTransType.OnlyTag;
}
row["tagTrans"] = tagCompleteRow.KeyName;
row["LCID"] = -1;
tableTagsTranslate.Rows.Add(row);
}
//if (_tagsValuesTrans.Rows.Count == COUNT_ROW)
//{
this.ImportDataTableInDb(ref tableTagsTranslate, new GetTable(GetTableTagsValuesTrans));
//}
}
public PostsSearchProvider(ISearcher searcher, ILogger <BaseSearchProvider <Post> > logger,
TagsRepository tagsRepository, PostsRepository postsRepository) : base(searcher,
logger)
{
_tagsRepository = tagsRepository;
_postsRepository = postsRepository;
}
private static async Task ProcessTagAddedEvent(TagsRepository tagrepo, TagAddedEvent evt)
{
switch (evt.Tag.Name)
{
case "step":
await tagrepo.RemoveTagFromHost(evt.TagId, evt.HostId);
var tags = await tagrepo.GetTagsForHost(evt.Host.Id);
if (!tags.Any(x => x.Name == "prepare") && !tags.Any(x => x.Name == "restart") && !tags.Any(x => x.Name == "complete"))
{
await tagrepo.AddTagToHost("prepare", evt.HostId);
}
else if (tags.Any(x => x.Name == "prepare") && !tags.Any(x => x.Name == "restart") && !tags.Any(x => x.Name == "complete"))
{
await tagrepo.RemoveTagFromHost("prepare", evt.HostId);
await tagrepo.AddTagToHost("restart", evt.HostId);
}
else if (!tags.Any(x => x.Name == "prepare") && tags.Any(x => x.Name == "restart") && !tags.Any(x => x.Name == "complete"))
{
await tagrepo.RemoveTagFromHost("restart", evt.HostId);
await tagrepo.AddTagToHost("complete", evt.HostId);
}
break;
}
}
private MemberRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out MemberTypeRepository memberTypeRepository)
{
memberTypeRepository = new MemberTypeRepository(unitOfWork, NullCacheProvider.Current);
var tagRepo = new TagsRepository(unitOfWork, NullCacheProvider.Current);
var repository = new MemberRepository(unitOfWork, NullCacheProvider.Current, memberTypeRepository, tagRepo);
return repository;
}
public UnitOfWork(EasyFindPropertiesEntities dbCtx)
{
_dbCtx = dbCtx;
PropertyType = new PropertyTypeRepository(_dbCtx);
AdPriority = new AdPriorityRepository(_dbCtx);
AdType = new AdTypeRepository(_dbCtx);
PropertyCategory = new PropertyCategoryRepository(_dbCtx);
PropertyCondition = new PropertyConditionRepository(_dbCtx);
PropertyImage = new PropertyImageRepository(_dbCtx);
PropertyPurpose = new PropertyPurposeRepository(_dbCtx);
PropertyRating = new PropertyRatingRepository(_dbCtx);
Property = new PropertyRepository(_dbCtx);
PropertyRequisition = new PropertyRequisitionRepository(_dbCtx);
SubscriptionType = new SubscriptionTypeRepository(_dbCtx);
Subscription = new SubscriptionRepository(_dbCtx);
TagType = new TagTypeRepository(_dbCtx);
Tennant = new TennantRepository(_dbCtx);
Owner = new OwnerRepository(_dbCtx);
Tags = new TagsRepository(_dbCtx);
Message = new MessageRepository(_dbCtx);
User = new UserRepository(_dbCtx);
UserType = new UserTypeRepository(_dbCtx);
UserTypeAssoc = new UserTypeAssocRepository(_dbCtx);
MessageTrash = new MessageTrashRepository(_dbCtx);
Meeting = new MeetingRepository(_dbCtx);
MeetingMembers = new MeetingMembersRepository(_dbCtx);
}
public override void SetUp()
{
base.SetUp();
item = CreateOneItem <PersistableItem2>(0, "item", null);
item.State = ContentState.Published;
repository = new TagsRepository(engine);
}
private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
{
var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current);
var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current);
contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, contentTypeRepository, templateRepository, tagRepository);
return repository;
}
protected BasePostsController(
BaseControllerContext <Post <TUserPk>, PostsRepository <TUserPk> > context,
TagsRepository tagsRepository,
ICommentsProvider <TUserPk> commentsProvider) : base(context)
{
TagsRepository = tagsRepository;
_commentsProvider = commentsProvider;
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Products = new ProductRepository(_context);
Categories = new CategoriesRepository(_context);
Tags = new TagsRepository(_context);
Subscribers = new SubscriberRepository(_context);
}
public AdminService(PodcastRepository podcastRepository,
TagsRepository tagsRepository,
PodcastService podcastService)
{
_podcastRepository = podcastRepository;
_tagsRepository = tagsRepository;
_podcastService = podcastService;
}
public TagsController(ILogger <TagsController> logger,
TagsRepository tagsRepository,
StoriesRepository storiesRepository)
{
_tagsRepository = tagsRepository;
_storiesRepository = storiesRepository;
_logger = logger;
}
public PostsRepository(BioRepositoryContext <Post> repositoryContext,
SectionsRepository sectionsRepository,
TagsRepository tagsRepository,
IUserDataProvider?userDataProvider = null) : base(repositoryContext,
sectionsRepository, userDataProvider)
{
_tagsRepository = tagsRepository;
}
public PostsController(BaseControllerContext <Post <string>, PostsRepository <string> > context,
TagsRepository tagsRepository, ICommentsProvider <string> commentsProvider,
IAuthorizationService authorizationService, ICurrentUserProvider <string> currentUserProvider) : base(
context, tagsRepository,
commentsProvider)
{
_authorizationService = authorizationService;
_currentUserProvider = currentUserProvider;
}
public async Task InsertTags(List <Tags> tags)
{
TagsRepository _repo = new TagsRepository();
foreach (var tag in tags)
{
await _repo.PutTag(tag);
}
}
public CourseDatabase()
{
Context = new DataContext();
Tasks = new TaskRepository(Context);
Users = new UserRepository(Context);
Tags = new TagsRepository(Context);
Answers = new AnswerRepository(Context);
Search = new SearchRepository();
}
public async Task UpdateTags(List <Tags> tags)
{
TagsRepository _repo = new TagsRepository();
foreach (var tag in tags)
{
await UpdateTag(tag);
}
}
public PostsRepository(BioRepositoryContext <Post <TUserPk> > repositoryContext,
SectionsRepository sectionsRepository,
TagsRepository tagsRepository,
IUserDataProvider <TUserPk>?userDataProvider = null) : base(repositoryContext,
sectionsRepository)
{
_tagsRepository = tagsRepository;
_userDataProvider = userDataProvider;
}
private ContentRepository CreateRepository(IDatabaseUnitOfWork unitOfWork, out ContentTypeRepository contentTypeRepository)
{
var templateRepository = new TemplateRepository(unitOfWork, NullCacheProvider.Current);
var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current);
contentTypeRepository = new ContentTypeRepository(unitOfWork, NullCacheProvider.Current, templateRepository);
var repository = new ContentRepository(unitOfWork, NullCacheProvider.Current, contentTypeRepository, templateRepository, tagRepository, CacheHelper.CreateDisabledCacheHelper());
return(repository);
}
public void Post([FromBody] CreateTagCommand request)
{
var repository = new TagsRepository();
repository.InsertImorTag(new ImorTag
{
Uri = request.Uri,
Description = request.Description,
Label = request.Label
});
}
private void GetTagsForImage()
{
var repository = new TagsRepository();
var results = repository.GetTagsForImage("CatImage");
foreach (var result in results)
{
Console.WriteLine(JsonConvert.SerializeObject(result));
}
}
public PodcastService(
PodcastRepository podcastRepository,
EpisodeRepository episodeRepository,
RssService rssService,
TagsRepository tagsRepository)
{
_podcastRepository = podcastRepository;
_episodeRepository = episodeRepository;
_rssService = rssService;
_tagsRepository = tagsRepository;
}
private void GetTagsTest()
{
var repository = new TagsRepository();
var results = repository.GetAllTags();
foreach (var result in results)
{
Console.WriteLine(JsonConvert.SerializeObject(result));
}
}
private void SearchImagesByTag()
{
var repo = new ImagesRepository();
var tagRepo = new TagsRepository();
var results = repo.SearchImagesByTag("http://www.semanticweb.org/ImagesOntology#DogTag");
foreach (var result in results)
{
Console.WriteLine(JsonConvert.SerializeObject(result));
}
}
public IEnumerable <ImorTag> Get()
{
try
{
var repo = new TagsRepository();
return(repo.GetAllTags());
}
catch (Exception e)
{
throw e;
}
}
public void MethodGetTest()
{
var mockSet = new Mock <DbSet <Tag> >();
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(m => m.Tags).Returns(mockSet.Object);
IRepository <Tag> tagsRepository = new TagsRepository(mockContext.Object);
tagsRepository.Get(1);
mockSet.Verify(m => m.Find(It.IsAny <int>()), Times.Once);
}
public void MethodGetAllTest()
{
var mockSet = new Mock <DbSet <Tag> >();
var mockContext = new Mock <ApplicationDbContext>();
mockContext.Setup(m => m.Tags).Returns(mockSet.Object);
mockSet.As <IEnumerable <Tag> >().Setup(m => m.GetEnumerator()).Returns((new List <Tag>()).GetEnumerator());
IRepository <Tag> tagsRepository = new TagsRepository(mockContext.Object);
var tags = tagsRepository.GetAll();
Assert.IsNotNull(tags);
}
public UnitOfWork(BlogDbContext context)
{
this.context = context;
CategoriesRepository = new CategoriesRepository(context);
PostsRepository = new PostsRepository(context);
PostsFetcher = new PostsFetcher(context);
TagsRepository = new TagsRepository(context);
CommentsFetcher = new CommentsFetcher(context);
CommentsRepository = new CommentsRepository(context);
PollsRepository = new PollsRepository(context);
PollAnswersRepository = new PollAnswersRepository(context);
PostPhotosRepository = new PostPhotosRepository(context);
PollsFetcher = new PollsFetcher(context);
VotesRepository = new VotesRepository(context);
}
public void Can_Create_Task_And_Delete_From_Repository()
{
TagsRepository repository = new TagsRepository(ConfigurationManager.ConnectionStrings["TaskTracker"].ConnectionString);
var testValue = "TestTag";
var tag = new Tag
{
Name = testValue
};
var newTag = repository.Save(tag);
Assert.That(newTag.Id, Is.Not.EqualTo(0));
Assert.That(newTag.Name, Is.EqualTo(testValue));
repository.Remove(newTag.Id);
Assert.That(repository.Find(newTag.Id), Is.Null);
}
private void ImportTagsTranslate(TagsRepository tagsRepository)
{
DataTable tableTagsTranslate = this.GetTableTagsValuesTrans();
TagCompleteRowEnumerator enumerator = tagsRepository.GetEnumerator();
while (enumerator.MoveNext())
{
TagCompleteRow tagCompleteRow = enumerator.Current;
DataRow row = tableTagsTranslate.NewRow();
row["tagHash"] = tagCompleteRow.KeyId;
if (tagCompleteRow.TypeValue == TypeValueTag.Id)
{
row["typeTrans"] = TagValueTransType.TagAndValue;
row["valueHash"] = tagCompleteRow.ValueId;
row["valTrans"] = tagCompleteRow.ValueName;
}
else
{
row["valueHash"] = Int32.MaxValue;
row["typeTrans"] = TagValueTransType.OnlyTag;
}
row["tagTrans"] = tagCompleteRow.KeyName;
row["LCID"] = -1;
tableTagsTranslate.Rows.Add(row);
}
//if (_tagsValuesTrans.Rows.Count == COUNT_ROW)
//{
this.ImportDataTableInDb(ref tableTagsTranslate, new GetTable(GetTableTagsValuesTrans));
//}
}
private static void InitializeTagsRepository()
{
TagsRepository = TagsRepository.Instance;
}
private TagsRepository CreateRepository(IDatabaseUnitOfWork unitOfWork)
{
var tagRepository = new TagsRepository(unitOfWork, NullCacheProvider.Current);
return tagRepository;
}