public ActionResult Registration(Models.UserModel user) { if (ModelState.IsValid) { using (var db= new MusicStoreContext()) { var crypto = new SimpleCrypto.PBKDF2(); var encrypPass = crypto.Compute(user.Password); var sysUser = db.User.Create(); sysUser.Email = user.Email; sysUser.Password = encrypPass; sysUser.PasswordSalt = crypto.Salt; db.User.Add(sysUser); db.SaveChanges(); return RedirectToAction("List", "Product"); } } return View(user); }
public StoreController( IGenreService genreService, MusicStoreContext dbContext, IOptions <AppSettings> options) { _genreService = genreService; _dbContext = dbContext; _appSettings = options.Value; }
public List <ArtistDTO> GetAllEnabled() { using (MusicStoreContext db = new MusicStoreContext()) { List <Artists> records = new List <Artists>(); records = db.Artists.Where(x => x.Enable == true).ToList(); return(_mapper.Map <List <ArtistDTO> >(records)); } }
public List <ArtistDTO> GetAll() { using (MusicStoreContext db = new MusicStoreContext()) { List <Artists> records = new List <Artists>(); records = db.Artists.ToList(); return(_mapper.Map <List <ArtistDTO> >(records)); } }
private static void PopulateData(MusicStoreContext context) { var genres = Enumerable.Range(1, 10).Select(n => new Genre { GenreId = n }); context.AddRange(genres); context.SaveChanges(); }
private async Task <List <Album> > GetTopSellingAlbumsAsync(MusicStoreContext dbContext, int count) { // Group the order details by album and return // the albums with the highest count return(await dbContext.Albums .OrderByDescending(a => a.OrderDetails.Count) .Take(count) .ToListAsync()); }
public AlbumController( IOptions <AppSettings> options, [FromServices] IDistributedCache cache, [FromServices] MusicStoreContext dbContext ) { _appSettings = options.Value; _cache = cache; _dbContext = dbContext; }
public ManageController(MusicStoreContext dbContext, ILogger <ManageController> logger // ,UserManager<ApplicationUser> userManager, // SignInManager<ApplicationUser> signInManager ) { DbContext = dbContext; _logger = logger; // UserManager = userManager; // SignInManager = signInManager; }
private async Task <List <Album> > GetTopSellingAlbumsAsync(MusicStoreContext dbContext, int count) { // Group the order details by album and return // the albums with the highest count // TODO [EF] We don't query related data as yet, so the OrderByDescending isn't doing anything return(await dbContext.Albums .OrderByDescending(a => a.OrderDetails.Count()) .Take(count) .ToListAsync()); }
public ShoppingCartController( IAlbumService albumService, IShoppingCartService shoppingCartService, MusicStoreContext dbContext, ILogger <ShoppingCartController> logger) { _albumService = albumService; _shoppingCartService = shoppingCartService; _dbContext = dbContext; _logger = logger; }
public void Music_store_project_to_mapped_entity() { var serviceProvider = new ServiceCollection() .AddEntityFramework() .AddInMemoryDatabase() .ServiceCollection() .BuildServiceProvider(); var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseInMemoryDatabase(); using (var db = new MusicStoreContext(serviceProvider, optionsBuilder.Options)) { var albums = GetAlbums("~/Images/placeholder.png", Genres, Artists); db.Genres.AddRange(Genres.Values); db.Artists.AddRange(Artists.Values); db.Albums.AddRange(albums); db.SaveChanges(); } using (var db = new MusicStoreContext(serviceProvider, optionsBuilder.Options)) { var q = from album in db.Albums join genre in db.Genres on album.GenreId equals genre.GenreId join artist in db.Artists on album.ArtistId equals artist.ArtistId select new Album { ArtistId = album.ArtistId, AlbumArtUrl = album.AlbumArtUrl, AlbumId = album.AlbumId, GenreId = album.GenreId, Price = album.Price, Title = album.Title, Artist = new Artist { ArtistId = album.ArtistId, Name = artist.Name }, Genre = new Genre { GenreId = album.GenreId, Name = genre.Name } }; var albums = q.ToList(); Assert.Equal(462, albums.Count); } }
private static string EnterSong(RequestConsumer reqConsumer, string controller) { Console.WriteLine("Enter title: "); string title = Console.ReadLine(); Console.WriteLine("Enter genre(optional): "); string genre = Console.ReadLine(); Console.WriteLine("Enter release date(optional): "); DateTime?releaseDate = null; try { releaseDate = DateTime.Parse(Console.ReadLine()); } catch (FormatException ex) { } MusicStoreContext db = new MusicStoreContext(); Console.WriteLine("Artist Name(optional): "); string artistName = Console.ReadLine(); var artist = (from a in db.Artists where a.Name == artistName select a ).FirstOrDefault(); Song newSong = new Song() { Title = title, Genre = genre, Year = releaseDate }; newSong.Artist = CreateArtistObject(artist.ArtistId, artist.Name, artist.Country, artist.DateOfBirth); Console.WriteLine("As Json(1) Or XML(2)? "); string choice = Console.ReadLine(); if (choice == "1") { var sent = reqConsumer.CreateAsJson <Song>(newSong, controller); return(sent); } else { var sent = reqConsumer.CreateAsXML <Song>(newSong, controller); return(sent); } }
public RegisterModel( UserManager <IdentityUser> userManager, SignInManager <IdentityUser> signInManager, ILogger <RegisterModel> logger, IEmailSender emailSender, MusicStoreContext context) { _userManager = userManager; _signInManager = signInManager; _logger = logger; _emailSender = emailSender; _context = context; }
public async Task <IEnumerable <Album> > Albums() { // For demonstration create individual instance var ctxt = new MusicStoreContext(); var result = await ctxt.Albums .Include(ctx => ctx.Tracks) .Include(ctx => ctx.Artist) .OrderBy(alb => alb.Title) .ToListAsync(); return(result); }
/// <summary> /// This method gets all albums from the database /// </summary> private void GetAllAlbums() { using (MusicStoreContext dataSource = new MusicStoreContext()) { //Query the Album Table using EF and LINQ var albums = (from allAlbums in dataSource.Albums select allAlbums); AlbamDataList.DataSource = albums.ToList(); // bind the result to the Album GridView AlbamDataList.DataBind(); } }
public async Task <object> Complete(MusicStoreContext context, int id) { var userName = "******"; var isValid = await context.Orders.AnyAsync( o => o.OrderId == id && o.Username == userName); if (isValid) { return(id); } return("Error"); }
public HomeController( IMusicRepository musicRepository, IUserRepository userRepository, IMusicRepository_ADONET musicRepository_adonet, IUserRepository_ADONET userRepository_ADONET, MusicStoreContext efContext) { _musicRepository = musicRepository; _userRepository = userRepository; _musicRepository_adonet = musicRepository_adonet; _userRepository_ADONET = userRepository_ADONET; _efContext = efContext; }
static void Main() { Database.SetInitializer(new MigrateDatabaseToLatestVersion<MusicStoreContext, Configuration>()); MusicStoreContext context = new MusicStoreContext(); Artist artist = new Artist() { Name = "Gosho", Country = "Bulgaria", DateOfBirth = new DateTime(2012, 5, 5) }; context.Artists.Add(artist); context.SaveChanges(); }
/// <summary> /// This Method gets the products data from the DataBase /// </summary> /*private void getMusicItem() * { * using (MusicStoreContext dataSource = new MusicStoreContext()) * { * //Query the Album Table using EF and LINQ * var albums = (from allAlbums in dataSource.Albums * select allAlbums); * // bind the result to the Album GridView * MusicGridView.DataSource = albums.ToList(); * * ///MusicGridView.DataSource = albums.AsQueryable().OrderBy(SortString).ToList(); * MusicGridView.DataBind(); * } * }*/ private void getMusicItem() { int GenreId = Convert.ToInt32(Request.QueryString["GenreId"]); using (MusicStoreContext dataSource = new MusicStoreContext()) { //Query the Album Table using EF and LINQ var albums = (from allAlbums in dataSource.Albums where allAlbums.GenreId == GenreId select allAlbums); // bind the result to the Album GridView AlbamDataList.DataSource = albums.ToList(); ///MusicGridView.DataSource = albums.AsQueryable().OrderBy(SortString).ToList(); AlbamDataList.DataBind(); } }
public MusicStoreContext CreateMusicStoreContext() { if (_connection == null) { _connection = new SqliteConnection("DataSource=:memory:"); _connection.Open(); var options = CreateOptions(); using (var context = new MusicStoreContext(options)) { context.Database.EnsureCreated(); } } return(new MusicStoreContext(CreateOptions())); }
public async Task <IActionResult> AddressAndPayment( [FromServices] MusicStoreContext dbContext, [FromForm] Order order, CancellationToken requestAborted) { if (!ModelState.IsValid) { return(View(order)); } var formCollection = await HttpContext.Request.ReadFormAsync(); try { if (string.Equals(formCollection["PromoCode"].FirstOrDefault(), PromoCode, StringComparison.OrdinalIgnoreCase) == false) { return(View(order)); } else { order.Username = HttpContext.User.Identity.Name; order.OrderDate = DateTime.Now; //Add the Order dbContext.Orders.Add(order); //Process the order var cart = ShoppingCart.GetCart(dbContext, HttpContext); await cart.CreateOrder(order); _logger.LogInformation("User {userName} started checkout of {orderId}.", order.Username, order.OrderId); // Save all changes await dbContext.SaveChangesAsync(requestAborted); return(RedirectToAction("Complete", new { id = order.OrderId })); } } catch (Exception ex) { _logger.LogError("Error occured while checkout.\r\n" + ex, order.Username, order.OrderId); //Invalid - redisplay with errors return(View(order)); } }
public async Task <AlbumViewModel> GetAlbumById(int id) { var album = new AlbumViewModel(); var db = new MusicStoreContext(); var exitAlbum = await _db.Album.FirstOrDefaultAsync(s => s.AlbumId == id); if (exitAlbum != null) { album.AlbumId = exitAlbum.AlbumId; album.ArtistName = exitAlbum.ArtistName; album.Title = exitAlbum.Title; album.GenreName = exitAlbum.GenreName; album.Price = exitAlbum.Price; album.PublicDate = exitAlbum.PublicDate; } return(album); }
/// <summary> /// This method gets the album from the Database /// </summary> private void BindAlbum() { int albumId = Convert.ToInt32(Request.QueryString["AlbumId"]); using (MusicStoreContext db = new MusicStoreContext()) { var album = (from oneAlbum in db.Albums join artist in db.Artists on oneAlbum.ArtistId equals artist.ArtistId join genre in db.Genres on oneAlbum.GenreId equals genre.GenreId where oneAlbum.AlbumId == albumId select new { AlbumArtUrl = oneAlbum.AlbumArtUrl, Title = oneAlbum.Title, Genre = genre.Name, Name = artist.Name, Price = oneAlbum.Price }); AlbumDetailRepeater.DataSource = album.ToList(); AlbumDetailRepeater.DataBind(); } }
public long Delete(ArtistDTO entity) { using (MusicStoreContext db = new MusicStoreContext()) { try { var record = db.Artists.Where(x => x.ArtistID == entity.ArtistID).FirstOrDefault(); record.Enable = entity.Enable; db.SaveChanges(); return(entity.ArtistID); } catch { return(0); } } }
public long Insert(SongDTO entity) { using (MusicStoreContext db = new MusicStoreContext()) { Songs record = _mapper.Map <Songs>(entity); try { var tempObj = db.Songs.Add(record); db.SaveChanges(); return(entity.SongID); } catch { return(0); } } }
// // GET: /Checkout/Complete public async Task <IActionResult> Complete( [FromServices] MusicStoreContext dbContext, int id) { // Validate customer owns this order bool isValid = await dbContext.Orders.AnyAsync( o => o.OrderId == id && o.Username == HttpContext.User.GetUserName()); if (isValid) { return(View(id)); } else { return(View("Error")); } }
public long Insert(ArtistDTO entity) { using (MusicStoreContext db = new MusicStoreContext()) { Artists record = _mapper.Map <Artists>(entity); try { var tempObj = db.Artists.Add(record); db.SaveChanges(); return(tempObj.ArtistID); } catch { return(0); } } }
private static void PopulateData(MusicStoreContext context, string cartId, string albumTitle, int itemCount) { var album = new Album() { AlbumId = 1, Title = albumTitle, }; var cartItems = Enumerable.Range(1, itemCount).Select(n => new CartItem() { AlbumId = 1, Album = album, Count = 1, CartId = cartId, }).ToArray(); context.AddRange(cartItems); context.SaveChanges(); }
// // GET: /Home/ public async Task <IActionResult> Index( [FromServices] MusicStoreContext dbContext, [FromServices] IDistributedCache cache) { // Get most popular albums var cacheKey = "topselling"; List <Album> albums = null; //try get top selling albums from cache var cachedalbums = cache.Get(cacheKey); if (cachedalbums == null) { //Get albums from database albums = await GetTopSellingAlbumsAsync(dbContext, 6); if (albums != null && albums.Count > 0) { if (_appSettings.CacheDbResults) { // Refresh it every 10 minutes. cache.Set( cacheKey, Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(albums)), new DistributedCacheEntryOptions() { AbsoluteExpiration = DateTimeOffset.UtcNow.AddMinutes(10) } ); } } } else { //deserialize cached albums albums = JsonConvert. DeserializeObject <List <Album> >(System.Text.Encoding.UTF8.GetString(cachedalbums)); } return(View(albums)); }
public AlbumControllerTests() { //Configuring In Memory Store for Unit Tests var optionsBuilder = new DbContextOptionsBuilder <MusicStoreContext>(); optionsBuilder.UseInMemoryDatabase(); //Create Data Context _musicStoreContext = new MusicStoreContext(optionsBuilder.Options); //Mocking dependencies _appSettings = new AppSettings() { CacheDbResults = true }; _options = new Mock <IOptions <AppSettings> >(); _options.SetupGet(p => p.Value).Returns(_appSettings); _distributedCache = new Mock <IDistributedCache>(); _albumController = new AlbumController(_options.Object, _distributedCache.Object, _musicStoreContext); }
static void Main() { MusicStoreContext context = new MusicStoreContext(); var album = new Album() { Title = "Title", Year = 2013, Producer = "Producer" }; context.Albums.Add(album); context.SaveChanges(); var query = from b in context.Albums select b; foreach (var item in query) { Console.WriteLine(item.Title); } }
public static void SeedDatabaseOrder(MusicStoreContext db) { var _Order = new Order() { OrderGuid = "12345", OrderDate = DateTime.Now, UserName = "******", FirstName = "123345", LastName = "12345", Address = "123214", City = "12345", State = "1234", PostalCode = "1234", Country = "123", Phone = "1234", Email = "1234", TotalPrice = 123 }; db.Order.Add(_Order); db.SaveChanges(); }
public long Update(SongDTO entity) { using (MusicStoreContext db = new MusicStoreContext()) { try { var record = db.Songs.Where(x => x.SongID == entity.SongID).FirstOrDefault(); record.ArtistID = entity.ArtistID; record.Title = entity.Title; record.YearReleased = entity.YearReleased; record.Enable = entity.Enable; db.SaveChanges(); return(entity.SongID); } catch { return(0); } } }
public AlbumsController() { var dbContext = new MusicStoreContext(); this.albumRepository = new DbAlbumsRepository(dbContext); }
private bool isValid(string email, string password) { var crypto = new SimpleCrypto.PBKDF2(); bool isValid = false; using (var db = new MusicStoreContext()) { var user = db.User.FirstOrDefault(u => u.Email == email); if (user != null) { if (user.Password == crypto.Compute(password, user.PasswordSalt)) { isValid = true; } } } return isValid; }
public SongsController() { var context = new MusicStoreContext(); this.songsRepository = new DbSongsRepository(context); }
public ArtistsController() { var dbContext = new MusicStoreContext(); this.artistRepository = new DbArtistsRepository(dbContext); }