public static async Task DeleteBlocksAsync <TEntity>(TEntity entity, BioContext dbContext)
where TEntity : IContentEntity
{
var blocks = await GetBlocksAsync(entity, dbContext);
dbContext.Blocks.RemoveRange(blocks);
}
public IPBContentPublisher(IPBApiClientFactory apiClientFactory, IContentRender contentRender,
BioContext dbContext,
ILogger <IPBContentPublisher> logger) : base(dbContext, logger)
{
_apiClientFactory = apiClientFactory;
_contentRender = contentRender;
}
public S3Storage(S3StorageModuleConfig options, StorageItemsRepository repository,
BioContext dbContext,
S3Client s3Client,
ILogger <S3Storage> logger) : base(options, repository, dbContext, logger)
{
_s3Client = s3Client;
}
public TwitterContentPublisher(TwitterService twitterService, BioContext dbContext,
ILogger <TwitterContentPublisher> logger, LinkGenerator linkGenerator) :
base(dbContext, logger)
{
_twitterService = twitterService;
_linkGenerator = linkGenerator;
}
public static async Task UpdateBlocksAsync <TEntity>(TEntity entity,
BioContext dbContext)
where TEntity : IContentEntity
{
var oldBlocks = await dbContext.Blocks
.Where(b => b.ContentId == entity.Id).AsNoTracking()
.ToListAsync();
foreach (var block in entity.Blocks)
{
block.ContentId = entity.Id;
var oldBlock = oldBlocks.FirstOrDefault(b => b.Id == block.Id);
if (oldBlock == null)
{
dbContext.Blocks.Add(block);
}
}
foreach (var oldBlock in oldBlocks)
{
var block = entity.Blocks.FirstOrDefault(b => b.Id == oldBlock.Id);
if (block == null)
{
dbContext.Remove(oldBlock);
}
else
{
dbContext.Attach(block);
dbContext.Update(block);
}
}
}
protected BaseCommentsProvider(BioContext dbContext,
IUserDataProvider <TUserPk> userDataProvider,
ILogger <BaseCommentsProvider <TUserPk> > logger)
{
DbContext = dbContext;
_userDataProvider = userDataProvider;
Logger = logger;
}
public IPBCommentsProvider(BioContext dbContext,
ILogger <IPBCommentsProvider> logger,
IPBModuleConfig options,
IUserDataProvider <string> userDataProvider)
: base(dbContext, userDataProvider, logger)
{
_options = options;
}
protected BioRepository(BioRepositoryContext <TEntity> repositoryContext)
{
DbContext = repositoryContext.DbContext;
Validators = repositoryContext.Validators ?? new List <IValidator <TEntity> >();
PropertiesProvider = repositoryContext.PropertiesProvider;
HooksManager = repositoryContext.HooksManager;
Init();
}
public FilesUploader(IHttpClientFactory httpClientFactory, IStorage storage, BioContext dbContext,
ILogger <FilesUploader> logger, IOptions <ImporterOptions> options)
{
_httpClientFactory = httpClientFactory;
_storage = storage;
_dbContext = dbContext;
_logger = logger;
_options = options.Value;
}
protected Storage(StorageModuleConfig options,
StorageItemsRepository repository,
BioContext dbContext,
ILogger <Storage> logger)
{
_repository = repository;
_dbContext = dbContext;
_logger = logger;
_options = options;
}
public static Task AddBlocksAsync <TEntity>(TEntity entity, BioContext dbContext)
where TEntity : IContentEntity
{
foreach (var block in entity.Blocks)
{
block.ContentId = entity.Id;
}
return(dbContext.AddRangeAsync(entity.Blocks));
}
public IPBCommentsSynchronizer(BioContext dbContext, SitesRepository sitesRepository,
PropertiesProvider propertiesProvider, IPBApiClientFactory ipbApiClientFactory,
ILogger <IPBCommentsSynchronizer> logger)
{
_dbContext = dbContext;
_sitesRepository = sitesRepository;
_propertiesProvider = propertiesProvider;
_ipbApiClientFactory = ipbApiClientFactory;
_logger = logger;
}
public IEnumerable <Bio> UserId(string userId)
{
var db = new BioContext();
var bio = db.Bio.Where(p => p.UserId == userId);
if (bio == null)
{
// TODO return error
}
return(bio.ToList());
}
public IActionResult Id(int id)
{
var db = new BioContext();
var bio = db.Bio.FirstOrDefault(p => p.Id == id);
if (bio == null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(bio));
}
public Importer(BioContext dbContext, ILogger <Importer> logger, FilesUploader filesUploader,
PropertiesProvider propertiesProvider, HtmlParser htmlParser,
LinkGenerator linkGenerator, IOptions <ImporterOptions> options)
{
_dbContext = dbContext;
_logger = logger;
_filesUploader = filesUploader;
_propertiesProvider = propertiesProvider;
_htmlParser = htmlParser;
_linkGenerator = linkGenerator;
_options = options.Value;
}
protected override void InitDbContext(BioContext dbContext)
{
var site = new Site {
Id = SiteId, Title = "Test site", Url = "https://test.ru"
};
dbContext.Add(site);
dbContext.SaveChanges();
var section = new TestSection
{
Title = "Test section",
Url = "test",
DatePublished = DateTimeOffset.Now,
IsPublished = true,
SiteIds = new[] { site.Id }
};
dbContext.Add(section);
dbContext.SaveChanges();
var content = new TestContent
{
Title = "Test content",
Url = "test2",
DatePublished = DateTimeOffset.Now,
IsPublished = true,
SiteIds = new[] { site.Id },
SectionIds = new[] { section.Id }
};
dbContext.Add(content);
var page = new TestContent
{
Title = "Test page",
Url = "test3",
DatePublished = DateTimeOffset.Now,
IsPublished = true,
SiteIds = new[] { site.Id }
};
dbContext.Add(page);
dbContext.SaveChanges();
}
public ContentItemValidator(BioContext dbContext)
{
RuleFor(e => e.Title).NotEmpty();
RuleFor(e => e.Url).NotEmpty();
RuleFor(e => e.Url).CustomAsync(async(url, context, _) =>
{
if (context.InstanceToValidate is IContentItem contentItem && contentItem.Id != Guid.Empty)
{
var count = await dbContext.Set <T>().Where(p => p.Url == url && p.Id != contentItem.Id)
.CountAsync();
if (count > 0)
{
context.AddFailure(
$"Url {url} already taken");
}
}
});
// RuleFor(e => e.AuthorId).NotEmpty();
RuleFor(e => e.Blocks).NotEmpty();
}
public PropertiesProvider(BioContext dbContext)
{
_dbContext = dbContext;
}
public ProfileManager(BioContext context, ILogger <ProfileManager> logger)
{
_context = context;
_logger = logger;
}
public FacebookContentPublisher(FacebookService facebookService, BioContext dbContext,
ILogger <FacebookContentPublisher> logger, LinkGenerator linkGenerator) : base(dbContext, logger)
{
_facebookService = facebookService;
_linkGenerator = linkGenerator;
}
protected BaseContentPublisher(BioContext dbContext,
ILogger <BaseContentPublisher <TConfig, TPublishRecord> > logger)
{
Logger = logger;
_dbContext = dbContext;
}
public FileStorage(FileStorageModuleConfig options, StorageItemsRepository repository,
BioContext dbContext, ILogger <FileStorage> logger) : base(options, repository, dbContext, logger)
{
_storagePath = options.StoragePath;
}
public static async Task <Dictionary <Guid, List <ContentBlock> > > GetBlocksAsync <TEntity>(TEntity[] entities,
BioContext dbContext)
where TEntity : IContentEntity
{
if (entities.Length == 0)
{
return(new Dictionary <Guid, List <ContentBlock> >());
}
var ids = entities.Select(e => e.Id).ToArray();
var blocks = await dbContext.Blocks
.Where(b => ids.Contains(b.ContentId)).ToListAsync();
return(ids.ToDictionary(id => id,
id => blocks.Where(b => b.ContentId == id).OrderBy(b => b.Position).ToList()));
}
public static async Task <List <ContentBlock> > GetBlocksAsync <TEntity>(TEntity entity,
BioContext dbContext)
where TEntity : IContentEntity
{
return((await GetBlocksAsync(new[] { entity }, dbContext))[entity.Id]);
}
public UpdateSiteIdsHook(BioContext dbContext)
{
_dbContext = dbContext;
}
protected virtual void InitDbContext(BioContext dbContext)
{
}
