| | SDK Installer | SDK Binaries | Runtime Installer | Runtime Binaries |
|---|---|---|---|---|
| Windows | 32-bit / 64-bit | 32-bit / 64-bit | 32-bit / 64-bit | 32-bit / 64-bit |
| macOS | 64-bit | 64-bit | 64-bit | 64-bit |
| Linux * | - | 64-bit | - | 64-bit |
| Ubuntu | See installations steps below | 64-bit | See installation steps below | 64-bit |
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
namespace SignalR04.Common
{
public class Counter
{
public string Name { set; get; }
public float Value { set; get; }
}
public class PerformanceCounterProvider
{
private readonly List<PerformanceCounter> _counters = new List<PerformanceCounter>();
public PerformanceCounterProvider()
{
_counters.Add(new PerformanceCounter("Processor", "% Processor Time", "_Total", readOnly: true));
_counters.Add(new PerformanceCounter("Memory", "Pages/sec", readOnly: true));
_counters.Add(new PerformanceCounter("PhysicalDisk", "% Disk Time", "_Total", readOnly: true));
}
public IList<Counter> GetResults()
{
return _counters.Select(c => new Counter
{
Name = c.CategoryName,
Value = c.NextValue()
}).ToList();
}
}
} using System.Threading;
using Microsoft.AspNet.SignalR;
using ThreadTimer = System.Threading.Timer;
namespace SignalR04.Common
{
public class PerformanceCounterHub : Hub
{
private ThreadTimer _threadTimer; //keep it alive
private readonly PerformanceCounterProvider _perfService = new PerformanceCounterProvider();
public PerformanceCounterHub()
{
_threadTimer = new ThreadTimer(timerCallback, null, Timeout.Infinite, 1000);
_threadTimer.Change(dueTime: 1000, period: 2000);
}
private void timerCallback(object state)
{
var results = _perfService.GetResults();
this.Clients.All.newCounters(results);
}
}
} <html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
<script src="Scripts/jquery-1.6.4.min.js" type="text/javascript"></script>
<script src="Scripts/jquery.signalR-1.1.3.min.js" type="text/javascript"></script>
<script type="text/javascript" src='<%= ResolveClientUrl("~/signalr/hubs") %>'></script>
<script src="Scripts/smoothie.js" type="text/javascript"></script>
</head>
<body>
<form id="form1" runat="server">
<div>
<div>
<h2>Processor</h2>
<canvas id="Processor" width="800" height="100"></canvas>
</div>
<div>
<h2>Memory</h2>
<canvas id="Memory" width="800" height="100"></canvas>
</div>
<div>
<h2>PhysicalDisk</h2>
<canvas id="PhysicalDisk" width="800" height="100"></canvas>
</div>
</div>
</form>
<script type="text/javascript">
var ChartEntry = function (name) {
var self = this;
self.name = name;
self.chart = new SmoothieChart({ millisPerPixel: 50, labels: { fontSize: 15} });
self.timeSeries = new TimeSeries();
self.chart.addTimeSeries(self.timeSeries, { lineWidth: 3, strokeStyle: "#00ff00" });
};
ChartEntry.prototype = {
addValue: function (value) {
var self = this;
self.timeSeries.append(new Date().getTime(), value);
},
start: function () {
var self = this;
self.canvas = document.getElementById(self.name);
self.chart.streamTo(self.canvas);
}
};
$(function () {
$.connection.hub.logging = true;
var performanceCounterHub = $.connection.performanceCounterHub;
var charts = [];
performanceCounterHub.client.newCounters = function (updatedCounters) {
$.each(updatedCounters, function (index, updateCounter) {
var entry;
$.each(charts, function (idx, chart) {
if (chart.name == updateCounter.Name) {
entry = chart;
return;
}
});
if (!entry) {
entry = new ChartEntry(updateCounter.Name);
charts.push(entry);
entry.start();
}
entry.addValue(updateCounter.Value);
});
};
$.connection.hub.start();
});
</script>
</body>
</html> 
public class ImageInfo
{
public Mat Image { set; get; }
public int ImageGroupId { set; get; }
public int ImageId { set; get; }
} public IList<ImageInfo> ReadTrainingImages(string path, string ext)
{
var images = new List<ImageInfo>();
var imageId = 1;
foreach (var dir in new DirectoryInfo(path).GetDirectories())
{
var groupId = int.Parse(dir.Name);
foreach (var imageFile in dir.GetFiles(ext))
{
var image = processTrainingImage(new Mat(imageFile.FullName, LoadMode.GrayScale));
if (image == null)
{
continue;
}
images.Add(new ImageInfo
{
Image = image,
ImageId = imageId++,
ImageGroupId = groupId
});
}
}
return images;
} private static Mat processTrainingImage(Mat gray)
{
var threshImage = new Mat();
Cv2.Threshold(gray, threshImage, Thresh, ThresholdMaxVal, ThresholdType.BinaryInv); // Threshold to find contour
Point[][] contours;
HiearchyIndex[] hierarchyIndexes;
Cv2.FindContours(
threshImage,
out contours,
out hierarchyIndexes,
mode: ContourRetrieval.CComp,
method: ContourChain.ApproxSimple);
if (contours.Length == 0)
{
return null;
}
Mat result = null;
var contourIndex = 0;
while ((contourIndex >= 0))
{
var contour = contours[contourIndex];
var boundingRect = Cv2.BoundingRect(contour); //Find bounding rect for each contour
var roi = new Mat(threshImage, boundingRect); //Crop the image
//Cv2.ImShow("src", gray);
//Cv2.ImShow("roi", roi);
//Cv.WaitKey(0);
var resizedImage = new Mat();
var resizedImageFloat = new Mat();
Cv2.Resize(roi, resizedImage, new Size(10, 10)); //resize to 10X10
resizedImage.ConvertTo(resizedImageFloat, MatType.CV_32FC1); //convert to float
result = resizedImageFloat.Reshape(1, 1);
contourIndex = hierarchyIndexes[contourIndex].Next;
}
return result;
} 
public CvKNearest TrainData(IList<ImageInfo> trainingImages)
{
var samples = new Mat();
foreach (var trainingImage in trainingImages)
{
samples.PushBack(trainingImage.Image);
}
var labels = trainingImages.Select(x => x.ImageGroupId).ToArray();
var responses = new Mat(labels.Length, 1, MatType.CV_32SC1, labels);
var tmp = responses.Reshape(1, 1); //make continuous
var responseFloat = new Mat();
tmp.ConvertTo(responseFloat, MatType.CV_32FC1); // Convert to float
var kNearest = new CvKNearest();
kNearest.Train(samples, responseFloat); // Train with sample and responses
return kNearest;
} public void DoOCR(CvKNearest kNearest, string path)
{
var src = Cv2.ImRead(path);
Cv2.ImShow("Source", src);
var gray = new Mat();
Cv2.CvtColor(src, gray, ColorConversion.BgrToGray);
var threshImage = new Mat();
Cv2.Threshold(gray, threshImage, Thresh, ThresholdMaxVal, ThresholdType.BinaryInv); // Threshold to find contour
Point[][] contours;
HiearchyIndex[] hierarchyIndexes;
Cv2.FindContours(
threshImage,
out contours,
out hierarchyIndexes,
mode: ContourRetrieval.CComp,
method: ContourChain.ApproxSimple);
if (contours.Length == 0)
{
throw new NotSupportedException("Couldn't find any object in the image.");
}
//Create input sample by contour finding and cropping
var dst = new Mat(src.Rows, src.Cols, MatType.CV_8UC3, Scalar.All(0));
var contourIndex = 0;
while ((contourIndex >= 0))
{
var contour = contours[contourIndex];
var boundingRect = Cv2.BoundingRect(contour); //Find bounding rect for each contour
Cv2.Rectangle(src,
new Point(boundingRect.X, boundingRect.Y),
new Point(boundingRect.X + boundingRect.Width, boundingRect.Y + boundingRect.Height),
new Scalar(0, 0, 255),
2);
var roi = new Mat(threshImage, boundingRect); //Crop the image
var resizedImage = new Mat();
var resizedImageFloat = new Mat();
Cv2.Resize(roi, resizedImage, new Size(10, 10)); //resize to 10X10
resizedImage.ConvertTo(resizedImageFloat, MatType.CV_32FC1); //convert to float
var result = resizedImageFloat.Reshape(1, 1);
var results = new Mat();
var neighborResponses = new Mat();
var dists = new Mat();
var detectedClass = (int)kNearest.FindNearest(result, 1, results, neighborResponses, dists);
//Console.WriteLine("DetectedClass: {0}", detectedClass);
//Cv2.ImShow("roi", roi);
//Cv.WaitKey(0);
//Cv2.ImWrite(string.Format("det_{0}_{1}.png",detectedClass, contourIndex), roi);
Cv2.PutText(
dst,
detectedClass.ToString(CultureInfo.InvariantCulture),
new Point(boundingRect.X, boundingRect.Y + boundingRect.Height),
0,
1,
new Scalar(0, 255, 0),
2);
contourIndex = hierarchyIndexes[contourIndex].Next;
}
Cv2.ImShow("Segmented Source", src);
Cv2.ImShow("Detected", dst);
Cv2.ImWrite("dest.jpg", dst);
Cv2.WaitKey();
} 
public IActionResult Get()
{
var userData = new User
{
Name = "Farhad",
Family = "Zamani"
};
_logger.LogInformation($"ValuesController called. Name:{userData.Name}, Family:{userData.Family}");
return Ok();
} 
اگر بخواهیم مرتب سازی و یا فیلتری را بر روی Name و یا Family انجام دهیم، کار آسانی نخواهد بود و وقت‌گیر خواهد بود؛ زیرا باید با یک فیلد رشته ( message )، که تمامی لاگ درون آن قرار دارد، کار کنیم. اما با استفاده از قابلیت Structured Logging مربوط به Serilog، می‌توانیم آبجکت userData را به ILogger پاس دهیم و پراپرتی‌های آن را به صورت فیلدهای جدا نمایش دهیم.
برای این کار باید آبجکت موردنظر خود را درون {} قرار دهیم و قبل از نام متغییر آن یک @ قرار دهیم. بدین صورت: {userData@} و سپس دیتای موردنظر را در پارامتر دوم logger قرار دهیم.
_logger.LogInformation("ValuesController called. {@userData}", userData); اگر کد نوشته شده مربوط به ثبت لاگ را به صورت زیر اصلاح کنیم:
public IActionResult Get()
{
var userData = new User
{
Name = "Farhad",
Family = "Zamani"
};
_logger.LogInformation("ValuesController called. {@userData}", userData);
return Ok();
} در پنل کیبانا به راحتی میتوان عملیات مرتب سازی و یا فیلتر را بر روی پراپرتی‌های Name و Family انجام دهیم. اکنون اگر پنل کیبانا را تماشا کنید چنین لاگی را مشاهده میکنیم:
هرکدام از پراپرتی‌های userData به صورت یک فیلد جدا ارسال شده‌است که به راحتی میتوانید مرتب سازی، فیلتر و... را بر روی هرکدام از فیلدها انجام دهید.
تنظیمات مربوط به Serilog:
public static void Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.Build();
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.Enrich.WithMachineName()
.Filter.ByExcluding(Matching.FromSource("Serilog"))
.Filter.ByExcluding(Matching.FromSource("System.Net.Http"))
.Filter.ByExcluding(Matching.FromSource("Microsoft.AspNetCore"))
.WriteTo.Console()
.ReadFrom.Configuration(configuration)
.CreateLogger();
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseSerilog()
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup<Startup>();
}); فایل appsettings.json:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
"AllowedHosts": "*",
"Serilog": {
"WriteTo": [
{
"Name": "Elasticsearch",
"Args": {
"nodeUris": "http://127.0.0.1:9200;",
"indexFormat": "structuredlogging-{0:yyyy.MM}",
"templateName": "structuredlogging"
}
}
]
}
} فایل docker-compose برای اجرای Elasticsearch و Kibana:
version: '3'
services:
elasticsearch:
container_name: elasticsearch
image: elasticsearch:7.14.2
environment:
- discovery.type=single-node
ports:
- 9200:9200
- 9300:9300
- 8200:8200
kibana:
container_name: kibana
image: kibana:7.14.2
ports:
- 5601:5601
منابع استفاده شده:
public async Task<IEnumerable<UserDto>> GetUsersInParallelInWithBatches(IEnumerable<int> userIds)
{
var tasks = new List<Task<IEnumerable<UserDto>>>();
var batchSize = 100;
int numberOfBatches = (int)Math.Ceiling((double)userIds.Count() / batchSize);
for (int i = 0; i < numberOfBatches; i++)
{
var currentIds = userIds.Skip(i * batchSize).Take(batchSize);
tasks.Add(client.GetUsers(currentIds));
}
return (await Task.WhenAll(tasks)).SelectMany(u => u);
}
[HttpPost]
public ActionResult ImageUpload(HttpPostedFileBase file)
{
string path = "";
var FileName = "";
if (file.ContentLength > 0)
{
FileName = Path.GetFileName(file.FileName);
string Extension = file.ContentType;
string[] ExtensionList = { "image/jpg", "image/jpeg", "image/gif", "image/pmg" };
if (ExtensionList.Contains(Extension.ToLower()))
{
path = Path.Combine(Server.MapPath("~/Images/uploads"), FileName);
file.SaveAs(path);
}
}
var array = new { filelink = @"Images\uploads\" + FileName };
return Json(array, System.Net.Mime.MediaTypeNames.Text.Plain, JsonRequestBehavior.AllowGet);
} 
public class StructureMapControllerFactory : DefaultControllerFactory
{
protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
{
if (controllerType == null)
{
throw new InvalidOperationException(string.Format("Page not found: {0}", requestContext.HttpContext.Request.Url.AbsoluteUri.ToString(CultureInfo.InvariantCulture)));
}
return ObjectFactory.GetInstance(controllerType) as Controller;
}
}
StructureMap Exception Code: 202
No Default Instance defined for PluginFamily MyProject.Controllers.HomeController, MyProject.Controllers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nullusing Microsoft.AspNetCore.Identity;
namespace BlazorServer.Entities
{
public class ApplicationUser : IdentityUser
{
public string Name { get; set; }
}
} public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
namespace BlazorWasm.WebApi
{
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
services.AddIdentity<ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
// ... dotnet tool update --global dotnet-ef --version 5.0.4 dotnet build dotnet ef migrations --startup-project ../../BlazorWasm/BlazorWasm.WebApi/ add AddNameToAppUser --context ApplicationDbContext dotnet ef --startup-project ../../BlazorWasm/BlazorWasm.WebApi/ database update --context ApplicationDbContext
using System.ComponentModel.DataAnnotations;
namespace BlazorServer.Models
{
public class UserRequestDTO
{
[Required(ErrorMessage = "Name is required")]
public string Name { get; set; }
[Required(ErrorMessage = "Email is required")]
[RegularExpression("^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$",
ErrorMessage = "Invalid email address")]
public string Email { get; set; }
public string PhoneNo { get; set; }
[Required(ErrorMessage = "Password is required.")]
[DataType(DataType.Password)]
public string Password { get; set; }
[Required(ErrorMessage = "Confirm password is required")]
[DataType(DataType.Password)]
[Compare("Password", ErrorMessage = "Password and confirm password is not matched")]
public string ConfirmPassword { get; set; }
}
} public class RegistrationResponseDTO
{
public bool IsRegistrationSuccessful { get; set; }
public IEnumerable<string> Errors { get; set; }
} using System;
using BlazorServer.Entities;
using BlazorServer.Models;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using System.Linq;
using BlazorServer.Common;
namespace BlazorWasm.WebApi.Controllers
{
[Route("api/[controller]/[action]")]
[ApiController]
[Authorize]
public class AccountController : ControllerBase
{
private readonly SignInManager<ApplicationUser> _signInManager;
private readonly UserManager<ApplicationUser> _userManager;
private readonly RoleManager<IdentityRole> _roleManager;
public AccountController(SignInManager<ApplicationUser> signInManager,
UserManager<ApplicationUser> userManager,
RoleManager<IdentityRole> roleManager)
{
_roleManager = roleManager ?? throw new ArgumentNullException(nameof(roleManager));
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_signInManager = signInManager ?? throw new ArgumentNullException(nameof(signInManager));
}
[HttpPost]
[AllowAnonymous]
public async Task<IActionResult> SignUp([FromBody] UserRequestDTO userRequestDTO)
{
var user = new ApplicationUser
{
UserName = userRequestDTO.Email,
Email = userRequestDTO.Email,
Name = userRequestDTO.Name,
PhoneNumber = userRequestDTO.PhoneNo,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userRequestDTO.Password);
if (!result.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return BadRequest(new RegistationResponseDTO { Errors = errors, IsRegistrationSuccessful = false });
}
var roleResult = await _userManager.AddToRoleAsync(user, ConstantRoles.Customer);
if (!roleResult.Succeeded)
{
var errors = result.Errors.Select(e => e.Description);
return BadRequest(new RegistationResponseDTO { Errors = errors, IsRegistrationSuccessful = false });
}
return StatusCode(201); // Created
}
}
} [Route("api/[controller]/[action]")]
[ApiController]
[Authorize] 
using System.ComponentModel.DataAnnotations;
namespace BlazorServer.Models
{
public class AuthenticationDTO
{
[Required(ErrorMessage = "UserName is required")]
[RegularExpression("^[a-zA-Z0-9_.-]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$",
ErrorMessage = "Invalid email address")]
public string UserName { get; set; }
[Required(ErrorMessage = "Password is required.")]
[DataType(DataType.Password)]
public string Password { get; set; }
}
} using System.Collections.Generic;
namespace BlazorServer.Models
{
public class AuthenticationResponseDTO
{
public bool IsAuthSuccessful { get; set; }
public string ErrorMessage { get; set; }
public string Token { get; set; }
public UserDTO UserDTO { get; set; }
}
public class UserDTO
{
public string Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
public string PhoneNo { get; set; }
}
} namespace BlazorServer.Models
{
public class BearerTokensOptions
{
public string Key { set; get; }
public string Issuer { set; get; }
public string Audience { set; get; }
public int AccessTokenExpirationMinutes { set; get; }
}
} {
"BearerTokens": {
"Key": "This is my shared key, not so secret, secret!",
"Issuer": "https://localhost:5001/",
"Audience": "Any",
"AccessTokenExpirationMinutes": 20
}
} namespace BlazorWasm.WebApi
{
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
services.AddOptions<BearerTokensOptions>().Bind(Configuration.GetSection("BearerTokens"));
// ... using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using BlazorServer.Entities;
using BlazorServer.Models;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
namespace BlazorServer.Services
{
public interface ITokenFactoryService
{
Task<string> CreateJwtTokensAsync(ApplicationUser user);
}
public class TokenFactoryService : ITokenFactoryService
{
private readonly UserManager<ApplicationUser> _userManager;
private readonly BearerTokensOptions _configuration;
public TokenFactoryService(
UserManager<ApplicationUser> userManager,
IOptionsSnapshot<BearerTokensOptions> bearerTokensOptions)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
if (bearerTokensOptions is null)
{
throw new ArgumentNullException(nameof(bearerTokensOptions));
}
_configuration = bearerTokensOptions.Value;
}
public async Task<string> CreateJwtTokensAsync(ApplicationUser user)
{
var signingCredentials = new SigningCredentials(
new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.Key)),
SecurityAlgorithms.HmacSha256);
var claims = await getClaimsAsync(user);
var now = DateTime.UtcNow;
var tokenOptions = new JwtSecurityToken(
issuer: _configuration.Issuer,
audience: _configuration.Audience,
claims: claims,
notBefore: now,
expires: now.AddMinutes(_configuration.AccessTokenExpirationMinutes),
signingCredentials: signingCredentials);
return new JwtSecurityTokenHandler().WriteToken(tokenOptions);
}
private async Task<List<Claim>> getClaimsAsync(ApplicationUser user)
{
string issuer = _configuration.Issuer;
var claims = new List<Claim>
{
// Issuer
new Claim(JwtRegisteredClaimNames.Iss, issuer, ClaimValueTypes.String, issuer),
// Issued at
new Claim(JwtRegisteredClaimNames.Iat, DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64, issuer),
new Claim(ClaimTypes.Name, user.Email, ClaimValueTypes.String, issuer),
new Claim(ClaimTypes.Email, user.Email, ClaimValueTypes.String, issuer),
new Claim("Id", user.Id, ClaimValueTypes.String, issuer),
new Claim("DisplayName", user.Name, ClaimValueTypes.String, issuer),
};
var roles = await _userManager.GetRolesAsync(user);
foreach (var role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role, ClaimValueTypes.String, issuer));
}
return claims;
}
}
} namespace BlazorWasm.WebApi
{
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
services.AddScoped<ITokenFactoryService, TokenFactoryService>();
// ... namespace BlazorWasm.WebApi.Controllers
{
[Route("api/[controller]/[action]")]
[ApiController]
[Authorize]
public class AccountController : ControllerBase
{
private readonly SignInManager<ApplicationUser> _signInManager;
private readonly UserManager<ApplicationUser> _userManager;
private readonly ITokenFactoryService _tokenFactoryService;
public AccountController(
SignInManager<ApplicationUser> signInManager,
UserManager<ApplicationUser> userManager,
ITokenFactoryService tokenFactoryService)
{
_userManager = userManager ?? throw new ArgumentNullException(nameof(userManager));
_signInManager = signInManager ?? throw new ArgumentNullException(nameof(signInManager));
_tokenFactoryService = tokenFactoryService;
}
[HttpPost]
[AllowAnonymous]
public async Task<IActionResult> SignIn([FromBody] AuthenticationDTO authenticationDTO)
{
var result = await _signInManager.PasswordSignInAsync(
authenticationDTO.UserName, authenticationDTO.Password,
isPersistent: false, lockoutOnFailure: false);
if (!result.Succeeded)
{
return Unauthorized(new AuthenticationResponseDTO
{
IsAuthSuccessful = false,
ErrorMessage = "Invalid Authentication"
});
}
var user = await _userManager.FindByNameAsync(authenticationDTO.UserName);
if (user == null)
{
return Unauthorized(new AuthenticationResponseDTO
{
IsAuthSuccessful = false,
ErrorMessage = "Invalid Authentication"
});
}
var token = await _tokenFactoryService.CreateJwtTokensAsync(user);
return Ok(new AuthenticationResponseDTO
{
IsAuthSuccessful = true,
Token = token,
UserDTO = new UserDTO
{
Name = user.Name,
Id = user.Id,
Email = user.Email,
PhoneNo = user.PhoneNumber
}
});
}
}
} 
{
"iss": "https://localhost:5001/",
"iat": 1616396383,
"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name": "vahid@dntips.ir",
"http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress": "vahid@dntips.ir",
"Id": "582855fb-e95b-45ab-b349-5e9f7de40c0c",
"DisplayName": "vahid@dntips.ir",
"http://schemas.microsoft.com/ws/2008/06/identity/claims/role": "Admin",
"nbf": 1616396383,
"exp": 1616397583,
"aud": "Any"
} namespace BlazorWasm.WebApi
{
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
var bearerTokensSection = Configuration.GetSection("BearerTokens");
services.AddOptions<BearerTokensOptions>().Bind(bearerTokensSection);
// ...
var apiSettings = bearerTokensSection.Get<BearerTokensOptions>();
var key = Encoding.UTF8.GetBytes(apiSettings.Key);
services.AddAuthentication(opt =>
{
opt.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
opt.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
opt.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(cfg =>
{
cfg.RequireHttpsMetadata = false;
cfg.SaveToken = true;
cfg.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateAudience = true,
ValidateIssuer = true,
ValidAudience = apiSettings.Audience,
ValidIssuer = apiSettings.Issuer,
ClockSkew = TimeSpan.Zero,
ValidateLifetime = true
};
});
// ... namespace BlazorWasm.WebApi
{
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo { Title = "BlazorWasm.WebApi", Version = "v1" });
c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
In = ParameterLocation.Header,
Description = "Please enter the token in the field",
Name = "Authorization",
Type = SecuritySchemeType.ApiKey
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement {
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "Bearer"
}
},
new string[] { }
}
});
});
}
// ... 
private void TestResXResourceReader()
{
using (var reader = new ResXResourceReader("Resource1.fa.resx"))
{
foreach (var item in reader)
{
var resource = (DictionaryEntry)item;
Console.WriteLine("{0}: {1}", resource.Key, resource.Value);
}
}
}public class ResXResourceEntry
{
public string Key { get; set; }
public string Value { get; set; }
public ResXResourceEntry() { }
public ResXResourceEntry(object key, object value)
{
Key = key.ToString();
Value = value.ToString();
}
public ResXResourceEntry(DictionaryEntry dictionaryEntry)
{
Key = dictionaryEntry.Key.ToString();
Value = dictionaryEntry.Value != null ? dictionaryEntry.Value.ToString() : string.Empty;
}
public DictionaryEntry ToDictionaryEntry()
{
return new DictionaryEntry(Key, Value);
}
}private static List<ResXResourceEntry> Read(string filePath)
{
using (var reader = new ResXResourceReader(filePath))
{
return reader.Cast<object>().Cast<DictionaryEntry>().Select(de => new ResXResourceEntry(de)).ToList();
}
}private static void Write(IEnumerable<ResXResourceEntry> resources, string filePath)
{
using (var writer = new ResXResourceWriter(filePath))
{
foreach (var resource in resources)
{
writer.AddResource(resource.Key, resource.Value);
}
}
}private static void AddOrUpdate(ResXResourceEntry resource, string filePath)
{
var list = Read(filePath);
var entry = list.SingleOrDefault(l => l.Key == resource.Key);
if (entry == null)
{
list.Add(resource);
}
else
{
entry.Value = resource.Value;
}
Write(list, filePath);
}private static void Remove(string key, string filePath)
{
var list = Read(filePath);
list.RemoveAll(l => l.Key == key);
Write(list, filePath);
}
public class ResXResourceManager
{
private static readonly object Lock = new object();
public string ResourcesPath { get; private set; }
public ResXResourceManager(string resourcesPath)
{
ResourcesPath = resourcesPath;
}
public IEnumerable<ResXResourceEntry> GetAllResources(string resourceCategory)
{
var resourceFilePath = GetResourceFilePath(resourceCategory);
return Read(resourceFilePath);
}
public void AddOrUpdateResource(ResXResourceEntry resource, string resourceCategory)
{
var resourceFilePath = GetResourceFilePath(resourceCategory);
AddOrUpdate(resource, resourceFilePath);
}
public void DeleteResource(string key, string resourceCategory)
{
var resourceFilePath = GetResourceFilePath(resourceCategory);
Remove(key, resourceFilePath);
}
private string GetResourceFilePath(string resourceCategory)
{
var extension = Thread.CurrentThread.CurrentUICulture.TwoLetterISOLanguageName == "en" ? ".resx" : ".fa.resx";
var resourceFilePath = Path.Combine(ResourcesPath, resourceCategory.Replace(".", "\\") + extension);
return resourceFilePath;
}
private static void AddOrUpdate(ResXResourceEntry resource, string filePath)
{
var list = Read(filePath);
var entry = list.SingleOrDefault(l => l.Key == resource.Key);
if (entry == null)
{
list.Add(resource);
}
else
{
entry.Value = resource.Value;
}
Write(list, filePath);
}
private static void Remove(string key, string filePath)
{
var list = Read(filePath);
list.RemoveAll(l => l.Key == key);
Write(list, filePath);
}
private static List<ResXResourceEntry> Read(string filePath)
{
lock (Lock)
{
using (var reader = new ResXResourceReader(filePath))
{
var list = reader.Cast<object>().Cast<DictionaryEntry>().ToList();
return list.Select(l => new ResXResourceEntry(l)).ToList();
}
}
}
private static void Write(IEnumerable<ResXResourceEntry> resources, string filePath)
{
lock (Lock)
{
using (var writer = new ResXResourceWriter(filePath))
{
foreach (var resource in resources)
{
writer.AddResource(resource.Key, resource.Value);
}
}
}
}
}public class BuildManager
{
public string ProjectPath { get; private set; }
public BuildManager(string projectPath)
{
ProjectPath = projectPath;
}
public void Build()
{
var regKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\MSBuild\ToolsVersions\4.0");
if (regKey == null) return;
var msBuildExeFilePath = Path.Combine(regKey.GetValue("MSBuildToolsPath").ToString(), "MSBuild.exe");
var startInfo = new ProcessStartInfo
{
FileName = msBuildExeFilePath,
Arguments = ProjectPath,
WindowStyle = ProcessWindowStyle.Hidden
};
var process = Process.Start(startInfo);
process.WaitForExit();
}
}public class ResXResourceFileManager
{
public static readonly string BinPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase.Replace("file:///", ""));
public static readonly string ResourcesPath = Path.Combine(BinPath, @"..\App_Data\Resources");
public static readonly string ResourceProjectPath = Path.Combine(ResourcesPath, "Resources.csproj");
public static readonly string DefaultsPath = Path.Combine(ResourcesPath, "Defaults");
public static void CopyDlls()
{
File.Copy(Path.Combine(ResourcesPath, @"bin\debug\Resources.dll"), Path.Combine(BinPath, "Resources.dll"), true);
File.Copy(Path.Combine(ResourcesPath, @"bin\debug\fa\Resources.resources.dll"), Path.Combine(BinPath, @"fa\Resources.resources.dll"), true);
Directory.Delete(Path.Combine(ResourcesPath, "bin"), true);
Directory.Delete(Path.Combine(ResourcesPath, "obj"), true);
}
public static void RestoreAll()
{
RestoreDlls();
RestoreResourceFiles();
}
public static void RestoreDlls()
{
File.Copy(Path.Combine(DefaultsPath, @"bin\Resources.dll"), Path.Combine(BinPath, "Resources.dll"), true);
File.Copy(Path.Combine(DefaultsPath, @"bin\fa\Resources.resources.dll"), Path.Combine(BinPath, @"fa\Resources.resources.dll"), true);
}
public static void RestoreResourceFiles(string resourceCategory)
{
RestoreFile(resourceCategory.Replace(".", "\\"));
}
public static void RestoreResourceFiles()
{
RestoreFile(@"Global\Configs");
RestoreFile(@"Global\Exceptions");
RestoreFile(@"Global\Paths");
RestoreFile(@"Global\Texts");
RestoreFile(@"ViewModels\Employees");
RestoreFile(@"ViewModels\LogOn");
RestoreFile(@"ViewModels\Settings");
RestoreFile(@"Views\Employees");
RestoreFile(@"Views\LogOn");
RestoreFile(@"Views\Settings");
}
private static void RestoreFile(string subPath)
{
File.Copy(Path.Combine(DefaultsPath, subPath + ".resx"), Path.Combine(ResourcesPath, subPath + ".resx"), true);
File.Copy(Path.Combine(DefaultsPath, subPath + ".fa.resx"), Path.Combine(ResourcesPath, subPath + ".fa.resx"), true);
}
}window.location.reload();
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return View(model);
}
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);
switch (result)
{
case SignInStatus.Success:
return RedirectToLocal(returnUrl);
case SignInStatus.LockedOut:
return View("Lockout");
case SignInStatus.RequiresVerification:
return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return View(model);
}
} var loggedinUser = await UserManager.FindAsync(model.Email, model.Password);
if (loggedinUser != null)
{
await UserManager.UpdateSecurityStampAsync(loggedinUser.Id);
} app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
}); OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>( TimeSpan.FromMinutes(0), // <-- Note the timer is set for zero (manager, user) => user.GenerateUserIdentityAsync(manager))
window.setInterval(function() {
$.ajax({
url:,
type: "Post",
dataType: "json",
success: function(data) {
if (!data) {
alert("Someone has logged in using your username and password!");
location.reload();
}
}
});
}, 60000); [AllowAnonymous]
public virtual ActionResult Authenticated()
{
return Json(User.Identity.IsAuthenticated);
} 