public async Task <float?> SumAsync(Expression <Func <TDataAccessModel, float?> > selector)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.SumAsync(selector).ConfigureAwait(false));
}
}
public async Task <float> SumAsync(Expression <Func <TEntity, float> > selector, Expression <Func <TEntity, bool> > where)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.SumAsync(selector, @where).ConfigureAwait(false));
}
}
public static void ExecuteStoredProcedure(IStoreProcedure storedProcedure)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
repository.ExecuteStoredProcedure(storedProcedure);
}
}
public static async Task <int> CountAsync()
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.CountAsync().ConfigureAwait(false));
}
}
public static async Task <int> CountAsync(Expression <Func <TEntity, bool> > where)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.CountAsync(@where).ConfigureAwait(false));
}
}
public static IEnumerable <TEntity> ExecuteStoredProcedureList(IStoreProcedure storedProcedure)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(repository.ExecuteStoredProcedureList <TEntity>(storedProcedure));
}
}
public static async Task <bool> IsUserIdAuthorizedAsync(string aspNetUserId, List <string> roleIdList)
{
if (string.IsNullOrWhiteSpace(aspNetUserId))
{
return(false);
}
using (var aspNetUsersRepository = RepoUnitOfWork.CreateRepository <AspNetUserRepository>())
{
var user = await aspNetUsersRepository.GetAsync(aspNetUserId, new[]
{
nameof(AspNetUser.AspNetRoles)
}).ConfigureAwait(false);
if (user == null)
{
return(false);
}
var isApproved = user.Status == (int)UserStatus.ACTIVE;
if (!isApproved)
{
return(false);
}
if (user.AspNetRoles == null)
{
return(false);
}
//if at least one role is found
return(roleIdList.Any(roleId => user.AspNetRoles.Any(role => role.Id == roleId)));
}
}
private static async Task <EntityContainer <Models.Subject> > GetOrderShiftsByFilter(SubjectRepository subjectsRepository, int currentPageNumber, int numberOfPages, StudentSubjectFilterModel model, IList <string> navigationProperties = null)
{
if (subjectsRepository == null)
{
subjectsRepository = RepoUnitOfWork.CreateRepository <SubjectRepository>();
}
using (var subjectQuery = GetFilterQuery(subjectsRepository, model, navigationProperties))
{
if (!subjectQuery.IsValid)
{
return(new EntityContainer <Models.Subject>
{
CurrentPage = 0,
TotalPages = 0,
Data = new List <Models.Subject>()
});
}
var orderedQuery = subjectQuery.OrderBy(subject => subject.SubjectName).Paginate(currentPageNumber, PaginationConstants.REGISTRATION_PER_PAGE);
var subjectList = await orderedQuery.ExecuteAsync().ConfigureAwait(false);
if (subjectList == null)
{
subjectList = new List <Models.Subject>();
}
return(new EntityContainer <Models.Subject>
{
CurrentPage = currentPageNumber,
TotalPages = numberOfPages,
Data = subjectList.CopyTo <Models.Subject>().ToList()
});
}
}
public async Task <decimal?> MaxAsync(Expression <Func <TDataAccessModel, decimal?> > selector, Expression <Func <TDataAccessModel, bool> > where)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.MaxAsync(selector, @where).ConfigureAwait(false));
}
}
public async Task <int?> SumAsync(Expression <Func <TEntity, int?> > selector)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(await repository.SumAsync(selector).ConfigureAwait(false));
}
}
public static IConfigurableQuery <TEntity, TModel> GetListQuery(Expression <Func <TEntity, bool> > where, IList <string> navigationProperties = null)
{
var repository = RepoUnitOfWork.CreateRepository <TRepo>();
var query = repository.GetListQuery(@where, navigationProperties);
return(new ConfigurableQuery <TEntity, TModel>(repository.Context, query));
}
public static async Task <FilterEntityContainerWrapper <Models.Subject> > GetFiltered(int pageNumber = 0, StudentSubjectFilterModel model = null, IList <string> navigationProperties = null)
{
using (var subjectRepository = RepoUnitOfWork.CreateRepository <SubjectRepository>())
{
if (model == null)
{
model = StudentSubjectFilterModel.Default();
}
var entityContainerWraper = new FilterEntityContainerWrapper <Models.Subject>();
var entityContainers = new List <EntityContainer <Models.Subject> >();
var subjectQuery = subjectRepository.GetAllQuery(navigationProperties);
var offeredPaginationData = ExtractTotalPagesAsync(subjectQuery, model);
if (pageNumber > offeredPaginationData.TotalPages)
{
pageNumber = 0;
}
var offeredShiftsModel = await GetOrderShiftsByFilter(null, pageNumber, offeredPaginationData.TotalPages, model, navigationProperties).ConfigureAwait(false);
entityContainers.Add(offeredShiftsModel);
entityContainerWraper.EntityContainers = entityContainers;
entityContainerWraper.TotalItems = offeredPaginationData.TotalEntryCount;
return(entityContainerWraper);
}
}
public static IQueryable <TEntity> GetListQuery(Expression <Func <TEntity, bool> > where, IList <string> navigationProperties = null)
{
var repository = RepoUnitOfWork.CreateRepository <TRepo>();
var query = repository.GetListQuery(@where, navigationProperties);
return(query);
}
public static int Count(Expression <Func <TEntity, bool> > where)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
return(repository.Count(@where));
}
}
public static IConfigurableQuery <TEntity> GetAllQuery(IList <string> navigationProperties = null)
{
var repository = RepoUnitOfWork.CreateRepository <TRepo>();
var query = repository.GetAllQuery(navigationProperties);
return(new ConfigurableQuery <TEntity>(repository.Context, query));
}
public static TDataAccessModel GetEf(Guid id, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = repository.Get(id, navigationProperties);
return(entities);
}
}
public static IList <TEntity> GetAll(IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = repository.GetAll(navigationProperties);
return(entities);
}
}
public static IList <TEntity> GetListEF(Expression <Func <TEntity, bool> > where, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = repository.GetList(@where, navigationProperties);
return(entities);
}
}
public static TDataAccessModel GetSingle(Expression <Func <TDataAccessModel, bool> > where, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = repository.GetSingle(where, navigationProperties);
return(entities);
}
}
public static async Task <TEntity> GetSingleAsync(Expression <Func <TEntity, bool> > where, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entity = await repository.GetSingleAsync(where, navigationProperties);
return(entity);
}
}
public static async Task <AspNetUser> GetAsync(string userId, IList <string> navigationProperties = null)
{
using (var aspNetUsersRepository = RepoUnitOfWork.CreateRepository <AspNetUserRepository>())
{
var aspNetUser = await aspNetUsersRepository.GetAsync(userId, navigationProperties);
return(aspNetUser);
}
}
public static async Task <IList <TEntity> > GetAllEFAsync(IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = await repository.GetAllAsync(navigationProperties).ConfigureAwait(false);
return(entities);
}
}
//gets ENTITY FRAMEWORK OBJECT
public static async Task <TDataAccessModel> GetEfAsync(Guid id, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = await repository.GetAsync(id, navigationProperties).ConfigureAwait(false);
return(entities);
}
}
public static AspNetUser GetByEmail(string emailAddress, IList <string> navigationProperties = null)
{
using (var aspNetUsersRepository = RepoUnitOfWork.CreateRepository <AspNetUserRepository>())
{
var aspNetUser = aspNetUsersRepository.GetSingle(t => t.UserName == emailAddress, navigationProperties);
return(aspNetUser);
}
}
public static async Task <IList <TEntity> > GetListAsync(Expression <Func <TEntity, bool> > where, IList <string> navigationProperties = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = await repository.GetListAsync(@where, navigationProperties).ConfigureAwait(false);
return(entities);
}
}
public static async Task <IList <Models.Subject> > GetAllWithEntityStatusAsync(EntityStatus status, IList <string> navigationProperties = null)
{
using (var subjectRepository = RepoUnitOfWork.CreateRepository <SubjectRepository>())
{
var subjects = await subjectRepository.GetListAsync(subject => subject.EntityStatus == (int)status,
navigationProperties).ConfigureAwait(false);
return(subjects.CopyTo <Models.Subject>());
}
}
public static async Task <IList <StudentGroupAssigmentsModel> > GetAsync(Guid groupId)
{
using (var groupsRepository = RepoUnitOfWork.CreateRepository <DataLayer.GroupRepository>())
{
var group = await groupsRepository.GetAsync(groupId, new[]
{
nameof(Group.Students),
$"{nameof(Group.Students)}.{nameof(Student.Age)}"
}).ConfigureAwait(false);
return(group?.Students == null ? null : Process(group));
}
}
public static async Task <IList <TModel> > GetAllAsync(IList <string> navigationProperties = null, Func <TEntity, string> orderByExpression = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = await repository.GetAllAsync(navigationProperties).ConfigureAwait(false);
if (orderByExpression == null)
{
orderByExpression = entity => entity.Name;
}
return(entities.OrderBy(orderByExpression).CopyTo <TModel>());
}
}
public static async Task <IList <StudentSubjectAssigmentsModel> > GetAsync(Guid subjectId)
{
using (var subjectsRepository = RepoUnitOfWork.CreateRepository <DataLayer.SubjectRepository>())
{
var subject = await subjectsRepository.GetAsync(subjectId, new[]
{
nameof(Subject.Students),
$"{nameof(Subject.Students)}.{nameof(Student.Age)}"
}).ConfigureAwait(false);
return(subject?.Students == null ? null : Process(subject));
}
}
public static async Task <IList <TEntity> > GetAllAsync <TKey>(IList <string> navigationProperties = null, Func <TEntity, TKey> orderByExpression = null)
{
using (var repository = RepoUnitOfWork.CreateRepository <TRepo>())
{
var entities = await repository.GetAllAsync(navigationProperties).ConfigureAwait(false);
if (orderByExpression != null)
{
return(entities.OrderBy(orderByExpression).ToList());
}
return(entities);
}
}
