// ...
@*@attribute [Authorize]*@
@code
{
[CascadingParameter] public Task<AuthenticationState> AuthenticationState { get; set; }
protected override async Task OnInitializedAsync()
{
var authenticationState = await AuthenticationState;
if (!authenticationState.User.Identity.IsAuthenticated)
{
var uri = new Uri(NavigationManager.Uri);
NavigationManager.NavigateTo($"/identity/account/login?returnUrl={uri.LocalPath}");
}
// ... namespace BlazorServer.Common
{
public static class ConstantRoles
{
public const string Admin = nameof(Admin);
public const string Customer = nameof(Customer);
public const string Employee = nameof(Employee);
}
} {
"AdminUserSeed": {
"UserName": "vahid@dntips.ir",
"Password": "123@456#Pass",
"Email": "vahid@dntips.ir"
}
} namespace BlazorServer.Models
{
public class AdminUserSeed
{
public string UserName { get; set; }
public string Password { get; set; }
public string Email { get; set; }
}
} namespace BlazorServer.App
{
public class Startup
{
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions<AdminUserSeed>().Bind(Configuration.GetSection("AdminUserSeed"));
// ... using System;
using System.Linq;
using System.Threading.Tasks;
using BlazorServer.Common;
using BlazorServer.DataAccess;
using BlazorServer.Models;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
namespace BlazorServer.Services
{
public class IdentityDbInitializer : IIdentityDbInitializer
{
private readonly ApplicationDbContext _dbContext;
private readonly UserManager<IdentityUser> _userManager;
private readonly RoleManager<IdentityRole> _roleManager;
private readonly IOptions<AdminUserSeed> _adminUserSeedOptions;
public IdentityDbInitializer(
ApplicationDbContext dbContext,
UserManager<IdentityUser> userManager,
RoleManager<IdentityRole> roleManager,
IOptions<AdminUserSeed> adminUserSeedOptions)
{
_dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
_roleManager = roleManager ?? throw new ArgumentNullException(nameof(roleManager));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_adminUserSeedOptions = adminUserSeedOptions ?? throw new ArgumentNullException(nameof(adminUserSeedOptions));
}
public async Task SeedDatabaseWithAdminUserAsync()
{
if (_dbContext.Roles.Any(role => role.Name == ConstantRoles.Admin))
{
return;
}
await _roleManager.CreateAsync(new IdentityRole(ConstantRoles.Admin));
await _roleManager.CreateAsync(new IdentityRole(ConstantRoles.Customer));
await _roleManager.CreateAsync(new IdentityRole(ConstantRoles.Employee));
await _userManager.CreateAsync(
new IdentityUser
{
UserName = _adminUserSeedOptions.Value.UserName,
Email = _adminUserSeedOptions.Value.Email,
EmailConfirmed = true
},
_adminUserSeedOptions.Value.Password);
var user = await _dbContext.Users.FirstAsync(u => u.Email == _adminUserSeedOptions.Value.Email);
await _userManager.AddToRoleAsync(user, ConstantRoles.Admin);
}
}
} namespace BlazorServer.App
{
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped<IIdentityDbInitializer, IdentityDbInitializer>();
// ... using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Polly;
namespace BlazorServer.DataAccess.Utils
{
public static class MigrationHelpers
{
public static void MigrateDbContext<TContext>(
this IServiceProvider serviceProvider,
Action<IServiceProvider> postMigrationAction
) where TContext : DbContext
{
using var scope = serviceProvider.CreateScope();
var scopedServiceProvider = scope.ServiceProvider;
var logger = scopedServiceProvider.GetRequiredService<ILogger<TContext>>();
using var context = scopedServiceProvider.GetService<TContext>();
logger.LogInformation($"Migrating the DB associated with the context {typeof(TContext).Name}");
var retry = Policy.Handle<Exception>().WaitAndRetry(new[]
{
TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(15)
});
retry.Execute(() =>
{
context.Database.Migrate();
postMigrationAction(scopedServiceProvider);
});
logger.LogInformation($"Migrated the DB associated with the context {typeof(TContext).Name}");
}
}
} public static void Main(string[] args)
{
var host = CreateHostBuilder(args).Build();
host.Services.MigrateDbContext<ApplicationDbContext>(
scopedServiceProvider =>
scopedServiceProvider.GetRequiredService<IIdentityDbInitializer>()
.SeedDatabaseWithAdminUserAsync()
.GetAwaiter()
.GetResult()
);
host.Run();
} 
@attribute [Authorize(Roles = ConstantRoles.Admin)]
protected override async Task OnInitializedAsync()
{
var authenticationState = await AuthenticationState;
if (!authenticationState.User.Identity.IsAuthenticated ||
!authenticationState.User.IsInRole(ConstantRoles.Admin))
{
var uri = new Uri(NavigationManager.Uri);
NavigationManager.NavigateTo($"/identity/account/login?returnUrl={uri.LocalPath}");
} <form method="post" asp-action="Index" asp-controller="TestFileUpload" enctype="multipart/form-data"> <input type="file" name="files" multiple /> <input type="submit" value="Upload" /> </form>
[HttpPost] [ValidateAntiForgeryToken] public async Task<IActionResult> Index(IList<IFormFile> files)
public class TestFileUploadController : Controller
{
private readonly IHostingEnvironment _environment;
public TestFileUploadController(IHostingEnvironment environment)
{
_environment = environment;
} [HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Index(IList<IFormFile> files)
{
var uploadsRootFolder = Path.Combine(_environment.WebRootPath, "uploads");
if (!Directory.Exists(uploadsRootFolder))
{
Directory.CreateDirectory(uploadsRootFolder);
}
foreach (var file in files)
{
if (file == null || file.Length == 0)
{
continue;
}
var filePath = Path.Combine(uploadsRootFolder, file.FileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
await file.CopyToAsync(fileStream).ConfigureAwait(false);
}
}
return View();
} public class UserViewModel
{
[Required(ErrorMessage = "Please select a file.")]
[DataType(DataType.Upload)]
public IFormFile Photo { get; set; }
} @model UserViewModel <form method="post" asp-action="UploadPhoto" asp-controller="TestFileUpload" enctype="multipart/form-data"> <div asp-validation-summary="ModelOnly" class="text-danger"></div> <input asp-for="Photo" /> <span asp-validation-for="Photo" class="text-danger"></span> <input type="submit" value="Upload"/> </form>
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> UploadPhoto(UserViewModel userViewModel)
{
if (ModelState.IsValid)
{
var formFile = userViewModel.Photo;
if (formFile == null || formFile.Length == 0)
{
ModelState.AddModelError("", "Uploaded file is empty or null.");
return View(viewName: "Index");
}
var uploadsRootFolder = Path.Combine(_environment.WebRootPath, "uploads");
if (!Directory.Exists(uploadsRootFolder))
{
Directory.CreateDirectory(uploadsRootFolder);
}
var filePath = Path.Combine(uploadsRootFolder, formFile.FileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
await formFile.CopyToAsync(fileStream).ConfigureAwait(false);
}
RedirectToAction("Index");
}
return View(viewName: "Index");
} [FileExtensions(Extensions = ".png,.jpg,.jpeg,.gif", ErrorMessage = "Please upload an image file.")]
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public class UploadFileExtensionsAttribute : ValidationAttribute
{
private readonly IList<string> _allowedExtensions;
public UploadFileExtensionsAttribute(string fileExtensions)
{
_allowedExtensions = fileExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
public override bool IsValid(object value)
{
var file = value as IFormFile;
if (file != null)
{
return isValidFile(file);
}
var files = value as IList<IFormFile>;
if (files == null)
{
return false;
}
foreach (var postedFile in files)
{
if (!isValidFile(postedFile)) return false;
}
return true;
}
private bool isValidFile(IFormFile file)
{
if (file == null || file.Length == 0)
{
return false;
}
var fileExtension = Path.GetExtension(file.FileName);
return !string.IsNullOrWhiteSpace(fileExtension) &&
_allowedExtensions.Any(ext => fileExtension.Equals(ext, StringComparison.OrdinalIgnoreCase));
}
} public class UserViewModel
{
[Required(ErrorMessage = "Please select a file.")]
//`FileExtensions` needs to be applied to a string property. It doesn't work on IFormFile properties, and definitely not on IEnumerable<IFormFile> properties.
//[FileExtensions(Extensions = ".png,.jpg,.jpeg,.gif", ErrorMessage = "Please upload an image file.")]
[UploadFileExtensions(".png,.jpg,.jpeg,.gif", ErrorMessage = "Please upload an image file.")]
[DataType(DataType.Upload)]
public IFormFile Photo { get; set; }
} GetReportSnapshot = Url.Action(result: MVC.Report.CustomReportSnapshot()), //...
برای مثال با Angular و ASP.NET Core و یا ... Aurelia و ASP.NET Core یا .... کلا SPA متغیر، backend متغیر.
.NET Core 3.0 is representing a major step for the .NET community. It is interesting to analyze what’s new in the API directly from the compiled bits. In this post I will first explain how to diff .NET Core 3.0 against .NET Core 2.2 with NDepend, and then how to browse diff results.
PM> Install-Package Microsoft.Owin.Host.SystemWeb PM> Install-Package Microsoft.Owin.Security.Jwt PM> Install-Package structuremap PM> Install-Package structuremap.web
<appJwtConfiguration
tokenPath="/login"
expirationMinutes="2"
refreshTokenExpirationMinutes="60"
jwtKey="This is my shared key, not so secret, secret!"
jwtIssuer="http://localhost/"
jwtAudience="Any" /> <configSections>
<section name="appJwtConfiguration" type="JwtWithWebAPI.JsonWebTokenConfig.AppJwtConfiguration" />
</configSections> public interface ITokenStoreService
{
void CreateUserToken(UserToken userToken);
bool IsValidToken(string accessToken, int userId);
void DeleteExpiredTokens();
UserToken FindToken(string refreshTokenIdHash);
void DeleteToken(string refreshTokenIdHash);
void InvalidateUserTokens(int userId);
void UpdateUserToken(int userId, string accessTokenHash);
} public void CreateUserToken(UserToken userToken)
{
InvalidateUserTokens(userToken.OwnerUserId);
_tokens.Add(userToken);
} public interface IUsersService
{
string GetSerialNumber(int userId);
IEnumerable<string> GetUserRoles(int userId);
User FindUser(string username, string password);
User FindUser(int userId);
void UpdateUserLastActivityDate(int userId);
} public interface ISecurityService
{
string GetSha256Hash(string input);
} function doLogin() {
$.ajax({
url: "/login", // web.config --> appConfiguration -> tokenPath
data: {
username: "Vahid",
password: "1234",
grant_type: "password"
},
type: 'POST', // POST `form encoded` data
contentType: 'application/x-www-form-urlencoded' identity.AddClaim(new Claim(ClaimTypes.UserData, user.UserId.ToString()));
function doRefreshToken() {
// obtaining new tokens using the refresh_token should happen only if the id_token has expired.
// it is a bad practice to call the endpoint to get a new token every time you do an API call.
$.ajax({
url: "/login", // web.config --> appConfiguration -> tokenPath
data: {
grant_type: "refresh_token",
refresh_token: refreshToken
},
type: 'POST', // POST `form encoded` data
contentType: 'application/x-www-form-urlencoded' [JwtAuthorize(Roles = "Admin")] public class MyProtectedAdminApiController : ApiController
var jwtToken;
var refreshToken;
function doLogin() {
$.ajax({
// same as before
}).then(function (response) {
jwtToken = response.access_token;
refreshToken = response.refresh_token;
} function doCallApi() {
$.ajax({
headers: { 'Authorization': 'Bearer ' + jwtToken },
url: "/api/MyProtectedApi",
type: 'GET'
}).then(function (response) { function doLogout() {
$.ajax({
headers: { 'Authorization': 'Bearer ' + jwtToken },
url: "/api/user/logout",
type: 'GET' public AppOAuthProvider( Func<IUsersService> usersService, Func<ITokenStoreService> tokenStoreService, ISecurityService securityService, IAppJwtConfiguration configuration)
یک فروشگاه ساز ساده که با Angular 4.2 پیاده سازی شده است.
:Features
Add/Remove products to cart
Select/Clear filters based on category
Support for product variants
Cart checkout feature
Cash on delivery option
Authentication (Login/Signup)
using System;
using Microsoft.AspNetCore.Hosting;
namespace aspnetcoreapp
{
public class Program
{
public static void Main(string[] args)
{
var host = new WebHostBuilder()
.UseKestrel()
.UseStartup<Startup>()
.Build();
host.Run();
}
}
} // This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices (IServiceCollection services)
{
// Add framework services.
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddMvc();
// Add application services.
services.AddTransient<IEmailSender, AuthMessageSender>();
services.AddTransient<ISmsSender, AuthMessageSender>();
}