services.AddIdentity<IdentityUser, IdentityRole>(options =>
{
options.Password.RequiredLength = 10;
options.Password.RequiredUniqueChars = 2;
}).AddEntityFrameworkStores<AppDbContext>();
namespace DotNetCoreDemo.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class AccountController : Controller
{
private readonly UserManager<IdentityUser> userManager;
private readonly SignInManager<IdentityUser> signInManager;
public AccountController(UserManager<IdentityUser> userManager, SignInManager<IdentityUser> signInManager)
{
this.userManager = userManager;
this.signInManager = signInManager;
}
[HttpPost]
[Route("Register")]
public async Task<JsonResult> Post(VMRegister vmRegister)
{
IdentityResult result = new IdentityResult();
string errorMessage = "success";
if(ModelState.IsValid)
{
var user = new IdentityUser
{
UserName = vmRegister.Email,
Email = vmRegister.Email
};
result = await userManager.CreateAsync(user, vmRegister.Password);
if(result.Succeeded)
{
//to Signin user
//signInManager.SignInAsync(user, isPersistent: false).Start();
}
else
{
if(result.Errors.Count() > 0)
{
errorMessage = "";
foreach (var error in result.Errors)
{
errorMessage += error.Description;
}
}
}
}
return Json(new { id = "1", message = errorMessage });
}
}
}
body
{
"ResultCode": "OK",
"Message": "Success",
"Data": "demo@gmail.com"
}
"expression": {
"and": [
{
"equals": [
"@outputs('HttpStepName')['body']?['ResultCode']",
"OK"
]
}
]
},
namespace DemoFunctionApp
{
public class EmailUsers
{
public string ToEmail { get; set; }
}
public class Response
{
public string StatusCode { get; set; }
public string Message { get; set; }
public string Data { get; set; }
}
public static class Function1
{
[FunctionName("Function1")]
public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
var mailmessage = new MailMessage { From = new MailAddress("user@gmail.com", "UserName") };
var emailUsers = await req.Content.ReadAsAsync<EmailUsers>();
mailmessage.To.Add(emailUsers.ToEmail);
mailmessage.Subject = "Test email from function app" + System.DateTime.Now;
mailmessage.IsBodyHtml = true;
mailmessage.Body = "TEst email from function app" + System.DateTime.Now;
SmtpClient smtpClient = null;
smtpClient = new SmtpClient();
smtpClient.Host = "smtp.gmail.com";
smtpClient.Port = 587;
smtpClient.UseDefaultCredentials = false;
smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network;
smtpClient.Credentials = new NetworkCredential("user@gmail.com", "userEmailPassword");
smtpClient.EnableSsl = true;
smtpClient.Send(mailmessage);
Response response = new Response
{
StatusCode = HttpStatusCode.OK.ToString(),
Message = "Success",
Data = emailUsers.ToEmail
};
return req.CreateResponse(HttpStatusCode.OK, response);
}
}
}
namespace DotNetCodeDemo.Entities
{
public class Employee
{
public int Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
public Department Department { get; set; }
}
}
namespace DotNetCodeDemo.Entities
{
public class Department
{
public int Id { get; set; }
public string Name { get; set; }
public string Location { get; set; }
}
}
namespace DotNetCodeDemo.Repository.Contract
{
public interface IEmployeeRepository
{
Employee GetEmployee(int Id);
IEnumerable<Employee> GetAllEmployee();
Employee Add(Employee employee);
Employee Update(Employee employeeChanges);
Employee Delete(int Id);
}
}
namespace DotNetCodeDemo.Repository.Repositories
{
public class EmployeeRepository : IEmployeeRepository
{
private readonly AppDbContext dbContext;
public EmployeeRepository(AppDbContext dbContext)
{
this.dbContext = dbContext;
}
public Employee Add(Employee employee)
{
dbContext.Employees.Add(employee);
dbContext.SaveChanges();
return employee;
}
public Employee Delete(int Id)
{
var employee = dbContext.Employees.Find(Id);
if(employee != null)
{
dbContext.Employees.Remove(employee);
dbContext.SaveChanges();
}
return employee;
}
public IEnumerable<Employee> GetAllEmployee()
{
return dbContext.Employees;
}
public Employee GetEmployee(int Id)
{
return dbContext.Employees.Find(Id);
}
public Employee Update(Employee employeeChanges)
{
var employee = dbContext.Employees.Attach(employeeChanges);
employee.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
dbContext.SaveChanges();
return employeeChanges;
}
}
}
namespace DotNetCodeDemo.Repository.Helper
{
public static class ModelBuilderExtension
{
public static void Seed(this ModelBuilder modelBuilder)
{
modelBuilder.Entity<Employee>().HasData(
new Employee
{
Id = 1,
Name = "Demo1",
Email = "demo1@demo.com"
},
new Employee
{
Id = 2,
Name = "Demo2",
Email = "demo2@demo.com"
}
);
}
}
}
namespace DotNetCodeDemo.Repository
{
public class AppDbContext : DbContext
{
public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
{
}
public DbSet<Employee> Employees { get; set; }
public DbSet<Department> Departments { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Seed();
}
}
}
{
"Logging": {
"LogLevel": {
"Default": "Warning"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"DotNetCoreDB" : "data source=localhost; initial catalog=dotnetCoreDb; user id=sa; password=sa"
}
}
namespace DotNetCodeDemo
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContextPool<AppDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DotNetCoreDB")));
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddScoped<IEmployeeRepository, EmployeeRepository>();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseMvc();
}
}
}
namespace DotNetCodeDemo.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class EmployeeController : ControllerBase
{
private readonly IEmployeeRepository employeeRepository;
public EmployeeController(IEmployeeRepository employeeRepository)
{
this.employeeRepository = employeeRepository;
}
[HttpGet]
public ActionResult<IEnumerable<Employee>> Get()
{
return employeeRepository.GetAllEmployee().ToList();
}
}
}
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
namespace CoreDemo.Middleware
{
public class MyLoggerMiddleware
{
private readonly RequestDelegate _next;
private readonly ILogger _logger;
public MyLoggerMiddleware(RequestDelegate next, ILoggerFactory logFactory)
{
_next = next;
_logger = logFactory.CreateLogger("MyLogger");
}
public async Task Invoke(HttpContext httpContext)
{
_logger.LogInformation("test log");
//await _next(httpContext);
var bodyStream = httpContext.Response.Body;
var responseBodyStream = new MemoryStream();
httpContext.Response.Body = responseBodyStream;
await _next(httpContext);
responseBodyStream.Seek(0, SeekOrigin.Begin);
var responseBody = new StreamReader(responseBodyStream).ReadToEnd();
var responseCode = httpContext.Response.StatusCode;
var requestPath = httpContext.Request.Path;
var requestMethod = httpContext.Request.Method;
_logger.LogInformation($"@timeStamp = {DateTime.Now}, site = {"CoreDemo"}, Level = info, ThreadId = {Thread.CurrentThread.ManagedThreadId}, Message = logger Middleware response {responseBody}, request path = {requestPath}, request method = { requestMethod}");
responseBodyStream.Seek(0, SeekOrigin.Begin);
await responseBodyStream.CopyToAsync(bodyStream);
}
}
public static class MyLoggerMiddlewareExtension
{
public static IApplicationBuilder UseMyLoggerMiddleware(this IApplicationBuilder builder)
{
return builder.UseMiddleware<MyLoggerMiddleware>();
}
}
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
app.UseMyLoggerMiddleware();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc();
}