public DeckController(IRepoContext context, IMapper mapper, MTGService mtgservice, UserManager <IdentityUser> userManager)
{
_mtgService = mtgservice;
_context = context;
_userManager = userManager;
_mapper = mapper;
}
public CardController(MTGService mtgservice, IMapper mapper, IRepoContext context, IConversionService conversion, UserManager <IdentityUser> userManager)
{
_mtgService = mtgservice;
_mapper = mapper;
_context = context;
_conversion = conversion;
_userManager = userManager;
}
public virtual async Task <TEntity> CreateAsync(TEntity entity, IRepoContext context = null)
{
await this.DbSet.AddAsync(entity);
var count = await this.SaveChangesAsync();
return(count == 1?entity:default(TEntity));
}
public async Task <TEntity> DeleteAsync(TEntity entity, IRepoContext context = null)
{
//this.DbSet.Attach(entity);
var trace = this.DbSet.Remove(entity);
var count = await this.SaveChangesAsync();
return(count == 1?entity:default(TEntity));
}
public override Task <T> CreateAsync(T entity, IRepoContext context)
{
if ((entity as IEntity).Id == Guid.Empty)
{
(entity as IEntity).SetAssignedId(Guid.NewGuid());
}
return(base.CreateAsync(entity, context));
}
public DeckService(IDeckRepository deckRepository, IManaCostConverter manaCostConverter, ILogger <DeckService> logger, IMtgHttpClient mtgHttpClient, IRepoContext context, IMapper mapper)
{
_deckRepository = deckRepository;
_manaCostConverter = manaCostConverter;
_logger = logger;
_mtgHttpClient = mtgHttpClient;
_context = context;
_mapper = mapper;
}
public async Task <TEntity> ModifyAsync(TEntity entity, IRepoContext context = null)
{
//this.DbSet.Attach(entity);
var trace = this.DbSet.Update(entity);
//trace.State = EntityState.Modified;
var count = await this.SaveChangesAsync();
return(count == 1?entity:default(TEntity));
}
public async Task <TEntity> DeleteByIdAsync(TID id, IRepoContext context = null)
{
var entity = await this.GetByIdAsync(id, context);
if (entity == null)
{
return(default(TEntity));
}
return(await this.DeleteAsync(entity));
}
public KenticoSiteMapRepository(IRepoContext repoContext,
[FromServices] IPageDataContextRetriever dataContextRetriever,
IKenticoSiteMapRepositoryHelper Helper,
[FromServices] IPageUrlRetriever pageUrlRetriever,
IGeneralDocumentRepository generalDocumentRepository)
{
_dataContextRetriever = dataContextRetriever;
_Helper = Helper;
_pageUrlRetriever = pageUrlRetriever;
_generalDocumentRepository = generalDocumentRepository;
}
public virtual async Task <TEntity> GetByIdAsync(TID id, IRepoContext context = null)
{
return(await this.DbSet.FirstOrDefaultAsync(entity => (entity as IEntity <TID>).Id.Equals(id)));
}
public DapperRepository(IRepoContext ctx)
{
_ctx = ctx;
}
public override async Task <T> GetByIdAsync(Guid id, IRepoContext context = null)
{
return(await this.DbSet.FirstOrDefaultAsync(p => (p as IEntity <Guid>).Id == id));
}
public DeckController(IRepoContext context, MTGService mtgservice, IMapper mapper)
{
_context = context;
_mtgService = mtgservice;
_mapper = mapper;
}
public KenticoBreadcrumbRepositoryHelper(IRepoContext repoContext, IMapper Mapper)
{
_repoContext = repoContext;
_Mapper = Mapper;
}
public async Task <Pageable <TEntity> > ListAsync(Pageable <TEntity> pageable, IRepoContext context = null)
{
var expr = pageable.Expression;
IQueryable <TEntity> query = this.DbSet;
if (expr != null)
{
query = query.Where(expr);
}
long count = 0;
if (pageable.PageSize != 0)
{
if (expr != null)
{
//query = this.DbSet.Where(expr);
}
else
{
//query = this.DbSet;
}
count = await query.LongCountAsync();
pageable.RecordCount = count;
if (count == 0)
{
return(pageable);
}
}
//query = DbSet;
if (pageable.Asc != null)
{
query = query.OrderBy(pageable.Asc);
}
else if (pageable.Desc != null)
{
query = query.OrderByDescending(pageable.Desc);
}
if (pageable.PageSize > 0)
{
int pageSize = (int)pageable.PageSize;
var pageCount = count / pageSize;
if (count % pageSize > 0)
{
pageCount++;
}
pageable.PageCount = pageCount;
var pageIndex = pageable.PageIndex;
if (pageIndex == 0)
{
pageable.PageIndex = 1;
}
if (pageIndex > pageCount)
{
pageIndex = pageable.PageIndex = pageCount;
}
int skip = (int)((pageIndex - 1) * pageSize);
query = query.Skip(skip).Take(pageSize);
}
pageable.Items = await query.ToListAsync();
return(pageable);
}
public KenticoGeneralDocumentRepository(IRepoContext repoContext, ISiteService siteService)
{
_repoContext = repoContext;
this.siteService = siteService;
}
public KenticoNavigationRepositoryHelper(IRepoContext repoContext, IMapper Mapper, IServiceProvider serviceProvider)
{
_repoContext = repoContext;
_Mapper = Mapper;
_serviceProvider = serviceProvider;
}
public DeckRepository(ILogger <DeckRepository> logger, IRepoContext context)
{
_logger = logger;
_context = context;
}
public KenticoBreadcrumbRepository(IRepoContext repoContext, IKenticoBreadcrumbRepositoryHelper Helper, IServiceProvider services, IUrlResolver urlResolver)
{
_Helper = Helper;
_services = services;
UrlResolver = urlResolver;
}
public KenticoSiteMapRepositoryHelper(IRepoContext repoContext, IServiceProvider serviceProvider)
{
_repoContext = repoContext;
_serviceProvider = serviceProvider;
}
