public AccountController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, SignInManager <Account> signInManager, UserManager <Account> userManager, ILogger logger)
: base(dbContext, appSettings, logger)
{
_signInManager = signInManager;
_userManager = userManager;
_mapper = new AccountVmMapper(_userManager, DbContext);
}
public DashboardViewModel(GrowDbContext context, string selectedContestYear)
{
// Years
SelectedContestYear = selectedContestYear;
LatestContestYear = context.Contests.Max(c => c.Year);
// Selected contest stats
ParticipantCount = context
.Teams
.Where(t => t.Contest.Year == selectedContestYear)
.Where(t => t.IsActive)
.Select(t => t.Members)
.Where(m => m != null)
.Sum(m => m.Count);
VisitorCount = context
.EventResponses
.Where(r => r.Event.Contest.Year == selectedContestYear)
.Sum(r => r.ParticipantCount);
EventCount = context
.Events
.Where(e => e.Contest.Year == selectedContestYear)
.Where(e => e.IsActive)
.Count();
PrizeSum = context
.Prizes
.Where(p => p.Contest.Year == selectedContestYear)
.Where(p => p.IsActive)
.Sum(p => p.RewardValue);
// Edit data
EditData = GetEditStatistics(context);
}
public HomeController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
var storage = new Lazy <StorageConnector>(() => new StorageConnector(appSettings.Value, logger));
_mapper = new TeamVmMapper(DbContext, storage);
}
public static IEnumerable <SelectListItem> SelectListFromEntities <T>(GrowDbContext context) where T : BaseTimestampedEntity
{
var files = context
.Set <T>()
.OrderBy(e => e.Name);
return(SelectListFromEntityList(files));
}
public static IEnumerable <SelectListItem> SelectListFromEntities <T>(GrowDbContext context, int currentContestId) where T : BaseContestSubEntity
{
var files = context
.Set <T>()
.Where(e => e.ContestId == currentContestId)
.OrderBy(e => e.Name);
return(SelectListFromEntityList(files));
}
public static IEnumerable <SelectListItem> SelectListFromFiles <TSource>(GrowDbContext context, Expression <Func <TSource, File> > propertyLambda) where TSource : BaseEntity
{
var fileCategory = GetFileCategoryForProperty(propertyLambda);
var files = context
.Set <File>()
.Where(e => (e.Category ?? "misc").Equals(fileCategory.ToString(), StringComparison.CurrentCultureIgnoreCase))
.OrderBy(e => e.Name);
return(SelectListFromEntityList(files));
}
public void CreateTeams(GrowDbContext context, int contestId)
{
foreach (var team in TeamNames)
{
if (context.Teams.Any(t => t.Name.Equals(team, StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}
context.Teams.Add(new Team()
{
Name = team,
ContestId = contestId,
IsActive = true
});
}
context.SaveChanges();
}
private IEnumerable <IEnumerable <DateTime> > GetEditStatisticsForAllTables(GrowDbContext context, DateTime cutoffDate)
{
yield return(GetEditStatisticsForTable(Splice(context.Contests, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Events, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Files, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Partners, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Organizers, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Judges, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Mentors, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Teams, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.Prizes, cutoffDate)));
yield return(GetEditStatisticsForTable(Splice(context.CommonQuestion, cutoffDate)));
}
public async Task CreateAccounts(GrowDbContext context, AccountVmMapper mapper)
{
var errors = new List <string>();
var random = new Random();
TemporaryPasswords = new Dictionary <string, string>();
foreach (var(email, teamName) in Emails)
{
var teamId = context.Teams.FirstOrDefault(t => t.Name.Equals(teamName, StringComparison.InvariantCultureIgnoreCase))?.Id;
if (teamId == null)
{
errors.Add($"Email {email} was skipped since corresponding team was not found in the database");
continue;
}
var account = new AccountEditViewModel()
{
Email = email,
Name = email,
Password = random.Next(268435456, int.MaxValue).ToString("X"), //produces 8-char hex string
IsAdmin = false,
IsSuperAdmin = false,
IsActive = true,
TeamId = teamId
};
var result = await mapper.CreateAccountAsync(account).ConfigureAwait(false);
if (!result.Succeeded)
{
errors.Add(result.Errors.First().Description);
}
else
{
TemporaryPasswords.Add(email, account.Password);
}
}
}
public static void Main(string[] args)
{
Console.WriteLine("Starting database preparation");
// Extract connection string from arguments
string connectionString;
if (args.Length == 0 || string.IsNullOrEmpty(args[0]))
{
throw new ArgumentException("A connection string has to be provided as the first argument");
}
connectionString = args[0];
try
{
// Create context
var optionsBuilder = new DbContextOptionsBuilder <GrowDbContext>();
optionsBuilder.EnableSensitiveDataLogging(true);
optionsBuilder.UseSqlServer(connectionString);
var context = new GrowDbContext(optionsBuilder.Options);
// Reset data
Console.WriteLine("Resetting database");
context.ResetDatabase();
// Seed data
Console.WriteLine("Adding seed data");
context.SeedDataFrom2018();
context.SeedDataFrom2017();
Console.WriteLine("COMPLETED");
Console.ReadKey();
}
catch (Exception e)
{
Console.WriteLine("An error has occurred: " + e.Message);
Console.ReadKey();
}
}
private IDictionary <DateTime, int> GetEditStatistics(GrowDbContext context)
{
var editData = new SortedDictionary <DateTime, int>();
var cutoffDate = DateTime.Now.AddDays(-30).Date;
// fill with data
var data = GetEditStatisticsForAllTables(context, cutoffDate)
.SelectMany(enm => enm)
.GroupBy(dt => dt)
.Select(group => new KeyValuePair <DateTime, int>(group.Key, group.Count()));
editData.AddRange(data);
// fill holes in data
for (var date = cutoffDate; date <= DateTime.Now; date += new TimeSpan(1, 0, 0, 0))
{
if (!editData.ContainsKey(date))
{
editData.Add(date, 0);
}
}
return(editData);
}
protected BaseFrontendController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
GlobalFilter = (e => e.IsActive);
}
protected ApiController(GrowDbContext context, ILogger logger)
{
Context = context;
Logger = logger;
}
public ContestsController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
}
public MentorsController(GrowDbContext context, ILogger logger) : base(context, logger)
{
}
public TeamVmMapper(GrowDbContext dbContext, Lazy <StorageConnector> storage)
{
_dbContext = dbContext;
_storage = storage;
}
public FileController(GrowDbContext context, IOptions <AppSettings> settings, ILogger logger) : base(context, logger)
{
_storage = new Lazy <StorageConnector>(() => new StorageConnector(settings.Value, Logger));
}
public FileService(GrowDbContext context)
{
_context = context;
}
public AccountVmMapper(UserManager <Account> userManager, GrowDbContext dbContext)
{
_userManager = userManager;
_dbContext = dbContext;
}
protected BaseEntityAdminController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
}
public AuthService(IOptions <AppSettings> appSettings, GrowDbContext context)
{
_context = context;
_appSettings = appSettings.Value;
}
private static IEnumerable <FileUsage> FindFileReferences <TEntity, TProperty>(Func <TEntity, TProperty> propertyExpression, TProperty referenceValue, GrowDbContext context) where TEntity : BaseEntity
{
return(context
.Set <TEntity>()
.Where(e => referenceValue.Equals(propertyExpression(e)))
.Select(e =>
new FileUsage()
{
ReferrerId = e.Id,
ReferrerName = (e is BaseNamedEntity ? (e as BaseNamedEntity).Name : e.Id.ToString()),
ReferrerType = typeof(TEntity).Name
}
));
}
public FilesController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
_storage = new Lazy <StorageConnector>(() => new StorageConnector(AppSettings, Logger));
}
public AccountsController(UserManager <Account> userManager, GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger) : base(dbContext, appSettings, logger)
{
_userManager = userManager;
_mapper = new AccountVmMapper(userManager, DbContext);
}
public PartnersController(GrowDbContext context, ILogger logger) : base(context, logger)
{
}
protected BaseBackendController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger)
: base(dbContext, appSettings, logger)
{
}
public JudgesController(GrowDbContext context, ILogger logger) : base(context, logger)
{
}
public EventController(GrowDbContext dbContext, IOptions <AppSettings> appSettings, ILogger logger, UserManager <Account> userManager)
: base(dbContext, appSettings, logger)
{
UserManager = userManager;
}
public OrganizersController(GrowDbContext context, ILogger logger) : base(context, logger)
{
}
public static IEnumerable <FileIndexViewModel> ConvertToViewModels(IEnumerable <File> files, GrowDbContext context)
{
foreach (var file in files)
{
var vm = new FileIndexViewModel(file);
// crawl navigation properties for references to this file
vm.Uses.AddRange(FindFileReferences <Event, int?>(e => e.ImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Event, int?>(e => e.SlidesId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Organizer, int?>(e => e.ImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Mentor, int?>(e => e.ImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Judge, int?>(e => e.ImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Partner, int?>(e => e.ImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Team, int?>(e => e.TeamPhotoId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <Team, int?>(e => e.LogoImageId, vm.Id, context));
vm.Uses.AddRange(FindFileReferences <EventResponse, string>(e => (e as TeamResponse)?.FileUrl, vm.Url, context));
yield return(vm);
}
}
