internal static async Task<OfficialEvent> GetEvent(string slug, SportDataContext db)
{
return await db.Events.OfType<OfficialEvent>()
.Include(e => e.SubEvents)
.Include(e => e.SubEvents.Select(s => s.Series))
.Include(e => e.SubEvents.Select(s => s.Map))
.Include(e => e.SubEvents.Select(s => s.Tag))
.Include(e => e.SubEvents.Select(s => s.Groups))
.Include("Series.Tag")
.Include("Series.Tag.News")
.Include("Series.Tag.News.Attachments")
.Include("Series.Tag.Files")
.Include("Series.Tag.Partners")
.Include("Series.Tag.Partners.Logo")
.Include("Series.Tag.Galleries")
.Include("Series.Tag.Galleries.Files")
.Include("SubEvents.Tag")
.Include("SubEvents.Tag.News")
.Include("SubEvents.Tag.News.Attachments")
.Include("SubEvents.Tag.Files")
.Include("SubEvents.Tag.Partners")
.Include("SubEvents.Tag.Partners.Logo")
.Include("SubEvents.Tag.Orders")
.Include("SubEvents.Tag.Orders.Group")
.Include("SubEvents.Tag.Orders.Car")
.Include("SubEvents.Tag.Orders.Team")
.Include("SubEvents.Tag.Orders.Driver")
.Include("SubEvents.Tag.Orders.CoDriver")
.Include("SubEvents.Tag.Accreditations")
.Include("SubEvents.Tag.Accreditations.User")
.Include("SubEvents.Tag.Accreditations.Media")
.Include("SubEvents.Tag.Galleries")
.Include("SubEvents.Tag.Galleries.Files")
.FirstOrDefaultAsync(e => e.Slug == slug);
}
//
// GET: /Partners/
public async Task<ActionResult> Public()
{
List<Partner> partners;
using (var ctx = new SportDataContext())
{
if (Properties.Settings.Default.DisplayMode == "Event")
{
var ev = await ctx.Events
.OfType<OfficialEvent>()
.Include("Series")
.Include("Series.Tag")
.Include("Series.Tag.Partners")
.Include("Series.Tag.Partners.Logo")
.Include("SubEvents")
.Include("SubEvents.Tag")
.Include("SubEvents.Tag.Partners")
.Include("SubEvents.Tag.Partners.Logo")
.FirstOrDefaultAsync(e => e.Slug == "current");
partners = ev.SubEvents.SelectMany(s => s.Tag != null ? s.Tag.Partners : new List<Partner>()).ToList();
partners = partners.Union(ev.Series.SelectMany(s=>s.Tag!=null? s.Tag.Partners : new List<Partner>())).Distinct().ToList();
}
else
{
partners = await ctx.Partners.Where(p => p.IsEnabled && p.Global).ToListAsync();
}
}
return View(partners.Select(p=>new PartnerListViewModel(p)).ToList());
}
private bool SkuExists(string sku)
{
using (var ctx = new SportDataContext())
{
return ctx.Products.Any(p => p.SKU == sku && p.Enabled);
}
}
internal static List<PartnerListViewModel> GetGlobal()
{
using (var ctx = new SportDataContext())
{
return ctx.Partners.Include(p=>p.Logo).Where(p => p.IsEnabled && p.Global).ToList().Select(p => new PartnerListViewModel(p)).ToList();
}
}
//[OutputCache(Duration = 60 * 60 * 24, Location = System.Web.UI.OutputCacheLocation.Downstream)]
public async Task<ActionResult> QR(string slug, int width=8)
{
QrEncoder encoder = new QrEncoder(ErrorCorrectionLevel.L);
using (var db = new SportDataContext())
{
var ev = await EventService.GetEvent(slug, db);
if (ev == null)
return HttpNotFound();
var url = "http://afspb.org.ru/timeline/";
if(ev.Season!=2014)
url += ev.Season + "/";
url += ev.Slug + "/Guide";
var qrCode = encoder.Encode(url);
GraphicsRenderer dRenderer = new GraphicsRenderer(
new FixedModuleSize(width, QuietZoneModules.Two),
Brushes.Black, Brushes.White);
using(var ms = new MemoryStream())
{
dRenderer.WriteToStream(qrCode.Matrix, ImageFormat.Png, ms);
return File(ms.ToArray(), "image/png");
}
}
}
internal static IEnumerable<NewsListViewModel> GetSeason(int year, string domain)
{
using (var ctx = new SportDataContext())
{
return NewsQueryable(ctx, domain)
.Where(n => n.Season == year).OrderByDescending(n => n.Date).ToList().Select(n => new NewsListViewModel(n));
}
}
public ActionResult Team(string name)
{
using (var ctx = new SportDataContext())
{
var teams = SearchService.FindTeam(name, ctx);
return Json(new { found = teams!=null }, JsonRequestBehavior.AllowGet);
}
}
internal static List<ViewModels.NewsListViewModel> GetTop3(string domain)
{
using (var ctx = new SportDataContext())
{
return
NewsQueryable(ctx, domain).OrderByDescending(n => n.Date).Take(3).ToList().Select(n => new NewsListViewModel(n)).ToList();
}
}
internal static async Task<User> FindUserName(string firstName, string lastName, SportDataContext ctx)
{
if (firstName == null && lastName==null) return null;
lastName = lastName.OrDefault().ToUpper();
var user = await ctx.Users.Include(u => u.Licenses).FirstOrDefaultAsync(u => (u.LastName == lastName && u.FirstName==firstName));
//if (user == null)
// user = await ctx.Users.Include(u => u.Licenses).FirstOrDefaultAsync(u => u.LastName + " "+ u.FirstName == lastName + " " + firstName);
return user;
}
public ActionResult SKU(string[] tokens)
{
using (var ctx = new SportDataContext())
{
var product = ctx.Products.FirstOrDefault(p => p.SKU == tokens[tokens.GetUpperBound(0)]);
if (product != null) return View(product);
return HttpNotFound();
}
}
public ActionResult ShopHome()
{
using (var ctx = new SportDataContext())
{
var items = ctx.Products.Where(p => p.Featured);
var categories = ctx.Categories.Where(c => c.Parent == null);
}
return Content("HOME");
}
internal static NewsDetailsViewModel Get(string slug, string domain)
{
using (var ctx = new SportDataContext())
{
var item = NewsQueryable(ctx, domain).FirstOrDefault(n => n.Slug == slug);
if (item == null) return null;
return new NewsDetailsViewModel(item);
}
}
private static IQueryable<News> NewsQueryable(SportDataContext ctx, string domain)
{
var newsList = ctx.News
.Include(n => n.Attachments)
.Include(n => n.Tags);
newsList = DomainFilterService.FilterNews(ctx, domain, newsList);
return newsList;
}
public ActionResult Logo(string url, string domain = "")
{
using (var db = new SportDataContext())
{
var site = db.Sites.FirstOrDefault(s => s.Domain.ToUpper() == domain.ToUpper());
if (site == null) return Content("<a href='/'><img width='150' src='" + url + "' alt=''></a>");
else return Content("<a href='http://" + Properties.Settings.Default.BaseDomain + "'><img width='150' src='" + url + "' alt=''></a>");
}
}
public async Task<ActionResult> Gallery(string slug)
{
using (var ctx = new SportDataContext())
{
var gallery = await ctx.Galleries.Include(g=>g.Files).FirstOrDefaultAsync(g => g.Slug == slug && g.IsPublic);
if (gallery == null) return HttpNotFound();
return View(new GalleryViewModel(gallery));
}
}
private async Task<ActionResult> Item(string slug)
{
using (var ctx = new SportDataContext())
{
var ev = await ctx.SubEvents.Include(e=>e.Map).FirstOrDefaultAsync(e => e.Tag.Id == slug);
if (ev == null) return HttpNotFound();
return View("Item", new ProgramDetailsViewModel(ev));
}
}
public async Task<ActionResult> Get(string slug)
{
using (var db = new SportDataContext())
{
var ev = await EventService.GetEvent(slug, db);
if (ev == null)
return HttpNotFound();
return View(new EventViewModel(ev));
}
}
internal static async Task<IEnumerable<TimelineListViewModel>> GetSeasonEvents(string domain, int activeSeason, SportDataContext ctx)
{
var evQuery = ctx.Events
.Include(e => e.Series).Include(e => e.Series.Select(s => s.Discipline))
.Where(ev => ev.Season == activeSeason);
evQuery = await DomainFilterService.FilterEventsAsync(ctx, domain, evQuery);
var events = evQuery.OrderBy(e => e.StartDate).ThenBy(e => e.FinishDate).ToList()
.Select(ev => new TimelineListViewModel(ev));
return events;
}
public async Task<ActionResult> Driver(string license)
{
using (var ctx = new SportDataContext())
{
var user = await SearchService.FindUser(license, ctx);
return Json(new {
found = user!=null,
lastName = user!=null? user.LastName : "",
firstName = user!=null? user.FirstName:"" },
JsonRequestBehavior.AllowGet);
}
}
public async Task<ActionResult> Index(string displayPeriod, string domain="", int season=2014)
{
var activeSeason = GetActiveSeason(displayPeriod, season);
using (var ctx = new SportDataContext())
{
var events = await EventService.GetSeasonEvents(domain, activeSeason, ctx);
ViewBag.Season = activeSeason;
return View(events);
}
}
internal static IQueryable<News> FilterNews(SportDataContext ctx, string domain, IQueryable<News> newsList)
{
domain = domain ?? "";
var site = ctx.Sites
.Include(s => s.Tags)
.FirstOrDefault(s => s.Domain.ToUpper()==domain.ToUpper());
if (site != null)
{
newsList = newsList.ToList().Where(n => n.Tags.Any(t => site.Tags.Contains(t))).AsQueryable();
}
return newsList;
}
internal static async Task<List<OfficialEvent>> GetUpcommingList(DateTime actualDate, SportDataContext db, string domain)
{
var events = db.Events.OfType<OfficialEvent>()
.Include(e => e.SubEvents).Include("SubEvents.Groups")
.Include(e=>e.Series)
.Where(e => e.FinishDate > actualDate && (e.AccreditationsEnabled || e.SubEvents.Any(s => s.TimingSystemId != null || s.Groups.Any())));
var eventsFiltered = await DomainFilterService.FilterEventsAsync(db,domain,events);
if (eventsFiltered is IDbAsyncEnumerable)
return await eventsFiltered.OfType<OfficialEvent>().ToListAsync();
else
return eventsFiltered.OfType<OfficialEvent>().ToList();
}
public ActionResult ShowCategory(string[] tokens)
{
using (var ctx = new SportDataContext())
{
Category category=null;
foreach (var token in tokens)
{
category = GetCategory(token, category, ctx);
if (category == null) return HttpNotFound();
}
return View(category);
}
}
public async Task<ActionResult> Entries(Guid id)
{
using (var ctx = new SportDataContext())
{
var ev = await ctx.SubEvents
.Include("Tag")
.Include("Tag.Orders")
.Include("Tag.Orders.Driver")
.Include("Tag.Orders.CoDriver")
.FirstAsync(e => e.SecondaryId == id);
var model = ev.Tag.Orders.Select(o => new CarResultItem(o)).ToList();
return Json(model.ToArray(), JsonRequestBehavior.AllowGet);
}
}
public async Task<ActionResult> Index(string domain)
{
using (var ctx = new SportDataContext())
{
//var tags = ctx.Tags
// .Include("Galleries").Include("Galleries.Files")
// .Where(t => t.Galleries.Where(g => g.IsPublic && g.Files.Any()).Any());
#warning TODO: фильтрация доменов!
//var galleries = await tags.SelectMany(t=>t.Galleries).Where(g => g.IsPublic).OrderByDescending(g=>g.PublicationTime).ToListAsync();
var galleries = await ctx.Galleries.Include(g => g.Files)
.Where(g => g.IsPublic && (g.Files.Any()|| (g.Code!=null && g.Code!=""))).OrderByDescending(g => g.PublicationTime).ToListAsync();
return View(galleries.Select(g => new GalleryViewModel(g)).ToList());
}
}
//
// GET: /Documents/
public ActionResult Index(int season = 2014, string domain="")
{
using (var ctx = new SportDataContext())
{
var tags = ctx.Tags
.Include(c => c.Files)
.OfType<DocumentGroup>().Where(t => t.Season == season)
.OrderBy(g=>g.Id).ToList()
.Select(t=> new DocumentsTagViewModel(t)).AsEnumerable();
ViewBag.Season = season;
if (!tags.Any())
{
return View("NoDocuments");
}
return View(tags);
}
}
public async Task<ActionResult> Public(string domain="")
{
var model = new DashboardViewModel();
model.Top3News = NewsProvider.GetTop3(domain);
model.GlobalPartners = PartnerProvider.GetGlobal();
model.Domain = domain;
var actualDate = DateTime.Today.AddDays(-5);
using (var db = new SportDataContext())
{
model.UpcommingEvents = await GetUpcommingEvents(actualDate, db, domain);
if (Properties.Settings.Default.ShowFeaturedOnMainPage)
model.FeaturedEvents = await GetFeaturedEvents(db, domain);
}
return View(model);
}
//
// GET: /Event/
public async Task<ActionResult> Index()
{
using (var ctx = new SportDataContext())
{
var ev = await ctx.Events
.OfType<OfficialEvent>()
.Include(e=>e.SubEvents)
.Include("SubEvents.Map")
.Include("SubEvents.Tag")
.Include("SubEvents.Tag.Partners")
.Include("SubEvents.Tag.Partners.Logo")
.FirstOrDefaultAsync(e => e.Slug == "current");
if (ev == null) return View("CommingSoon");
return View(new EventDashboardViewModel(ev));
}
}
public ActionResult Generate(int width, int height, string name)
{
var path = Server.MapPath(ThumbnailService.GetThumbnailPath(name, width, height));
if (!DocumentService.IsFileExist(path))
{
using (var ctx = new SportDataContext())
{
var file = ctx.Files.FirstOrDefault(f => f.FileName == name);
if (file == null)
{
return HttpNotFound();
}
else
{
path = ThumbnailService.GenerateThumbnail(file, width, height);
}
}
}
return File(path, "application/octet-stream");
}
public ActionResult Featured(bool isMenu, string domain="")
{
using(var db= new SportDataContext()) {
var actualDate = DateTime.Today.AddDays(-5); //5 дней после окончания событие продолжает висеть
var items = EventService.GetFeaturedEvents(db, domain);
if (isMenu)
{
var model = items.ToList();
return PartialView("_FeaturedMenu", model);
}
else
{
var model = items.Where(e=>e.FinishDate>=actualDate).ToList();
return PartialView("_FeaturedBanner", model);
}
}
}
public UnitOfWork()
{
this._context = new SportDataContext();
}
public ApplicationRoleStore(SportDataContext context) : base(context)
{
}
public void ReloadContext()
{
this._context = new SportDataContext();
}
