Microsoft.Net Developer

Azure : LogicApp If Condition

Here is sample code to send email using Azure function app

API Response

body
{
    "ResultCode": "OK",
    "Message": "Success",
    "Data": "demo@gmail.com"
}

If Condition Step, get http API response result value, Here we are getting above result and want to get value of "ResultCode", and based on we need to perform another action, so we can get it as below,

 "expression": {
 "and": [
  {
  "equals": [
   "@outputs('HttpStepName')['body']?['ResultCode']",
   "OK"
  ]
  }
 ]
},

Hope this will help you and save your time.

Enjoy !!!

Azure : Function App

Here is sample code to send email using Azure function app

Encryption


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);
        }
    }
}

Hope this will help you and save your time.

Enjoy !!!

.Net Core : Database Connectivity

Model

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; }
    }
}

Repository

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();
        }
    }
}

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DotNetCoreDB" :  "data source=localhost; initial catalog=dotnetCoreDb; user id=sa; password=sa"
  }
}

Startup.cs

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();
        }
    }
}

API Controller

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();
        }
    }
}

Hope this will help you and save your time.

Enjoy !!!

.Net Core : Logging system

Log messages in .net core.

Step 1

Create custom logger class

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>();
        }
    }
}

Step 2

startup.cs

  public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseMyLoggerMiddleware();

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            
            app.UseMvc();
        }

Hope this will help you and save your time.

Enjoy !!!

Angular 6 : call API in Angular

Countrydetail class



export class CountryDetail {

    CountryId: number;

    CountryName: string;  

}

country.service.ts



import { Injectable } from '@angular/core';

import { HttpClient, HttpHeaders } from '@angular/common/http'; 

import { environment } from '../../../environments/environment'; 

@Injectable()

export class CountryDetailService {

  private httpOptions = {

    headers: new HttpHeaders({

      'Content-Type': 'application/json; charset=utf-8'

    }),

  };

 

  constructor(private http: HttpClient) {

  }

  async getCountryDetail(countryId: number): Promise<CountryDetail> {

    let request = this.http.post(environment.apiUrl +  environment.countrydetailurl, { data: {CountryId: countryId} }, this.httpOptions).

      toPromise().

      then(res => {

        return res["d"] as CountryDetail;

      }).

      catch(err => {

        console.log(err);

        return null;

      });

    let result = await request;

    return result;

  }

}

country.component.ts



export class CountryComponent implements OnInit {

  spinnerService: any;

  public detail = new CountryDetail(); 

  showSpinner: boolean = true;

  constructor(private countryDetailService: CountryDetailService, private router: Router,

    private route: ActivatedRoute) {

    this.router.routeReuseStrategy.shouldReuseRoute = function () {

      return false;

    }

  }

  async ngOnInit() {

    const productId = +this.route.snapshot.queryParamMap.get('id');

    let data = await this.countryDetailService.getCountryDetail(productId);

    this.detail = data as CountryDetail;

    this.showSpinner = false;

  }

}

country.component.html



<table>

    <tr *ngFor="let country of detail">

      <td>country.CountryName</td>

      <td><a href="/detail/country.CountryId">Detail</a></td>

    </tr>

  </table>

Hope this will help you and save your time.

Enjoy !!!

Angular 6 : Find value from existing array, Update array value

Find value from existing array, Update array value in Angular 6, here I explained step by steps.


let ProductSizes = Array<Size>();
let productSize = new Size();
 
productSize.Quantity = size.Quantity;
productSize.SizeName = size.SizeName;
productSize.sizeId = size.sizeId;
     
Check Value from existing array     
let existingSize = this.ProductSizes.find(item=> item.sizeId== sizeId);

if(existingSize != null)
{
  let sizeIndex = this.ProductSizes.indexOf(existingSize);
  this.ProductSizes[sizeIndex] = productSize;
}
else
{
 this.ProductSizes.push(productSize);
}

Hope this will help you and save your time.

Enjoy !!!

Angular 6 : Multi Language Usage

We can use multi languages in Angular 6, here I explained step by steps.

Steps, how to use it.

Step 1

Install required packages

npm install @ngx-translate/core --save
npm install ngx-translate-http-loader --save

Step 2

Configuration

Create folder "i18n" in "assets" folder
Create language specific file like., en.json, gu.json, hn.json as many you have language
And store language specific value in .json file as below

en.json

{
    "Product": {
        "ProductName": "Name",  
        "ProductPrice": "Price"        
    }
}

gu.json

{
    "Product": {
        "ProductName": "નામ",  
        "ProductPrice": "કિંમત"        
    }
}

hn.json

hn.json
{
    "Product": {
        "ProductName": "नाम",  
        "ProductPrice": "किम्मत"        
    }
}

Step 3

app.module.ts

import { TranslateModule, TranslateLoader, TranslateService } from '@ngx-translate/core';
import { TranslateHttpLoader } from "@ngx-translate/http-loader";
import { HttpClientModule, HttpClient } from '@angular/common/http';

export function HttpLoaderFactory(http: HttpClient) {
  return new TranslateHttpLoader(http);
}

imports: [
    BrowserModule,
    AppRoutingModule,
    ReactiveFormsModule,
    HttpClientModule,
    FormsModule, 
    TranslateModule.forRoot({
      loader: {
        provide: TranslateLoader,
        useFactory: HttpLoaderFactory,
        deps: [HttpClient]
      }
    })
  ],
  providers: [RecordsService],
  bootstrap: [AppComponent]
})

Step 4

app.component.ts

import { Component, ElementRef } from '@angular/core'; 
import { Router, ActivatedRoute } from '@angular/router';
import { TranslateService } from '@ngx-translate/core';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
    
showLoadingIndicator = true;

constructor(private router : Router, private route: ActivatedRoute, private eleRef: ElementRef,public translate: TranslateService ) { 
  //language start
  const langsArray: string[] = ['en', 'gu', 'hn'];
    translate.addLangs(langsArray);
      translate.setDefaultLang('en');
      let profileLanguage = this.eleRef.nativeElement.getAttribute('language');
    const browserLang: string =  translate.getBrowserLang();
    
    let UserLanguage = localStorage.getItem('UserLanguage'); 
    if(UserLanguage != null)
    {
      translate.use(UserLanguage);
    }
    else{
      if (profileLanguage) {
        translate.use(profileLanguage);
      } else {
        translate.use(langsArray.includes(browserLang) ? browserLang : 'en');
      }
    }    
  //language end  
}

  changeLanguage(lang) : void{     
    localStorage.setItem('UserLanguage', lang);
    this.translate.use(lang);
    this.router.routeReuseStrategy.shouldReuseRoute = () => false;
    this.router.onSameUrlNavigation = 'reload';
    this.router.navigate([this.router.url]);
  }
}

Step 5

app.component.html

 <select #langselect (change)="changeLanguage(langselect.value)">
      <option *ngFor="let lang of translate.getLangs()" [value]="lang">{{lang}}</option>
 </select>

Step 6

how to use language specific value

<h1>
    {{ 'Product.ProductName' | translate }}
</h1>
<h2>
    {{ 'Product.ProductPrice' | translate }}
</h2>

Hope this will help you and save your time.

Enjoy !!!