Best posts made by tnlthanzeel

This section is to briefly introduce how to configure entity framework core to and ASP.NET Core project and do few CRUD operations.

Prerequisite: atleast worked with Entity Framework 6

Create a class library project as a Data Access layer project in your solution so that the Web project and the the database can be separated.

Install the following nuget packages from the nuget manager to have entity frame work correctly configured.

1. To get the fully supported version of EFCore with sql, install Microsoft.entityframeworkcore.sqlserver from the nuget. This will pull in all the dependencies.
   To see the diagram of the tables, install https://marketplace.visualstudio.com/items?itemName=ErikEJ.EFCorePowerTools (read documentation for mo info).

2. In order to execute migrations, install the following tool and do the migration using the package manager console. EF Core2 doesn’t come with all the EF tools like in EF 6. Not everybody will run migrations. So if u want to run migrations install the following tool.

Using nuget package manager, install: Microsoft.entityframeworkcore.tools

• When running migrations, make sure that the package manager console points to the right project, which is the Data Access project

• To get a list of commands of EFcore, type “get-help entityframeworkcore”

Cmdlet                      Description

• -------------------------- ---------------------------------------------------
• Add-Migration Adds a new migration.
•
• Drop-Database Drops the database.
•
• Get-DbContext Gets information about a DbContext type.
•
• Remove-Migration Removes the last migration.
•
• Scaffold-DbContext Scaffolds a DbContext and entity types for a database.
•
• Script-Migration Generates a SQL script from migrations.

3. Once you run the add-migration command, I will get an error like this:

• This is because the Data project and the Domain project are class library projects. The StartUp project must have the references to the Data and the Domain project. There fore, add the reference to the StartUp project and install the following nuget package to the StartUp Project.

o Microsoft.entityframeworkcore.design

• This is because the design project needs and executable project and not a class library project .
• Set the executable project as the startup project.
• Now run the add-migration command again and it will succeed Inshah Allah

Model SnapShot file
• The model snapshot file is very important because this is where entity framework will keep track of the current state of the model. When a new migration is added the ef core will read the snapshot and compare it with the new version of the model and figures out what needs to be changed.

Migrations
• To create a sql script of the migration, type the command

Runnin this command will generate a sql script like the example below

IF OBJECT_ID(N'[__EFMigrationsHistory]') IS NULL
BEGIN
CREATE TABLE [__EFMigrationsHistory] (
[MigrationId] nvarchar(150) NOT NULL,
[ProductVersion] nvarchar(32) NOT NULL,
CONSTRAINT [PK___EFMigrationsHistory] PRIMARY KEY ([MigrationId])
);
END;

GO

CREATE TABLE [Battles] (
[Id] int NOT NULL IDENTITY,
[Name] nvarchar(max) NULL,
[StartDate] datetime2 NOT NULL,
[EndDate] datetime2 NOT NULL,
CONSTRAINT [PK_Battles] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [Samurais] (
[Id] int NOT NULL IDENTITY,
[Name] nvarchar(max) NULL,
[BattleId] int NOT NULL,
CONSTRAINT [PK_Samurais] PRIMARY KEY ([Id]),
CONSTRAINT [FK_Samurais_Battles_BattleId] FOREIGN KEY ([BattleId]) REFERENCES [Battles] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [Quotes] (
[Id] int NOT NULL IDENTITY,
[Text] nvarchar(max) NULL,
[SamuraiId] int NOT NULL,
CONSTRAINT [PK_Quotes] PRIMARY KEY ([Id]),
CONSTRAINT [FK_Quotes_Samurais_SamuraiId] FOREIGN KEY ([SamuraiId]) REFERENCES [Samurais] ([Id]) ON DELETE CASCADE
);

GO

CREATE INDEX [IX_Quotes_SamuraiId] ON [Quotes] ([SamuraiId]);

GO

CREATE INDEX [IX_Samurais_BattleId] ON [Samurais] ([BattleId]);

GO

INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
VALUES (N'20181113023641_init', N'2.1.4-rtm-31024');

GO

• Update the databse using the update-database command from the package manager console, this will create a db in your mssql server if the db doesn't exist r update it.

One-to-Many and-Many-to-Many

• One samaurai can fight in many battles and many samurais can fight in one battles. There for many to many relationship.
• Create a new table (many to many relationship) as SamuriBattle.
• Create the many to many relationship relationship using the ef core fluent API in the SamuriContext file.
• Here, we have a composite primary key

Logging sql script created by Ef core

• install the package Microsoft.Extensions.Logging.Console to SamaruiAppData (the class libabry project for the db access) project

This code must be added to the App datacontext class which inherits the DbContext class so we can see the generated sql

Inserting a list of objects to databse using ef core 2

Inserting different types of objects to the database using AddRange() method in ef core 2

Usling Like() in ef core 2

• use the like() method instead of contains which will finally convert into a Like() method taking in a wild card.
• EF is a built in function

selecting the last recored using LastOrDefault()

• Here, the ef core will generate a sql ordered by decending and select the top.

• If orderBy() is not included, the sql will return a list to the memory and then will select the last record which is a performance hit.

Using the Find() method

• The Find method will return an object by taking in the primary key of the entity. If the entity is tracked by the context in will be return from the memory without doing a call to the database. Cool ha!

Disconnected Updates

• Here, there is no tracking of the entity by the dbcontext
• We can use the Update method to update the object without tracking what properties have been change.

• Here all though only the EndDate has been changed, the context object is different when updating the object.
• The Using statement will create a new context object and pass the entity to the Update method.
• All the properties will be updated, not just only the EndDate

Simplified methods

Deleting

• Delete can be done using the Remove() method if u have the entity object to pass into the Remove() function.
• If u have only the primary key, we can use a raw sql command to execute stored procedure.

Eager Loading

• The “ThenInclude()” method drills down into the Quotes which is in the “Include()” and retrieves that data as well

Projection

• The below query brings out only the samarui object without the Quotes. This query will look for any samurai that has the word ”happy ” in any of its quotes. Quotes is not included in the result set

Entry method

• When updating a related object when there is no tracking, use the method Entry() and set the entity state to modified as in the image above. This will tell the ef core to only update the modified related object. Not all the object.
• If we use the update method, it will update all the related objects even if there are no changes.

if java spring boot, u can use the application.properties file with code

#DATA SOURCE
spring.datasource.url=jdbc:mysql://db4free.net:3306/xxxdb?useSSL=false
spring.datasource.username=xxxdb
spring.datasource.password=xxxx

#HIBERNATE PROPERTIES
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect
spring.jpa.hibernate.ddl-auto=update

security.ignored=/**

#server.contextPath=/api
server.port=8080

https://snipcart.com/blog/angular-seo-universal-server-side-rendering

oh then i dont know bro, but i found this
https://stackoverflow.com/questions/212539/java-equivalent-to-app-config

setting up angualar project using cli is easier if u leverage the power of it, in addition,if u are a backend developer u can code just like OOP as angular uses typescript which makes developling much easier rather than having namespace collisions in pure javascript

choose whats best for u

Introduction

At times when developing applications, we may come across scenarios where the data sent to a server via http has to be verified to check whether the data has been manipulated when traveling across the wire to the server. This verification is required to check for the authenticity of the data.

Today, let us discuss about how to digitally sign data, often referred as DigitalSignature, and verify the DigitalSignature and data sent to a server using azure key-vault certificate and C#. This DigitalSignature can be then sent along with the data as a part of the request header or by other means according to the usage.

Keywords

1. DigitalSignature – the data that’s digitally signed using a certificate

2. Data – the message or document sent to a server via http post request most often

3. Azure key-vault – a service provider in the cloud that provides a secure store for secrets.
   Read more on azure key-vault at
   https://azure.microsoft.com/en-us/services/key-vault/

Pre-requisites

• Have some basic understanding about azure
• Understanding of asymmetric cryptography
• Working knowledge in C#
• Azure subscription

1. Setting up an Azure key-vault certificate

In this section lets us create a certificate on azure key vault.

1. First, create an azure key-vault resource, if you already have a Key-Vault resource you can use it.

2. In the left menu, under the “Settings” section select “Certificates”.


3. Once navigated to the certificate section, click on “Generate/Import”

4. The above action will take you to the page where it allows you to create or import a new certificate. Since we are creating a new certificate, select “Generate” from the “Method of Certificate Create” dropdown, and fill in the fields. Most of them can be left to the defaults selected. DON’T click on Create yet.


5. Once you come to the bottom of the form, click for the highlighted section as shown in above image. This will open a side bar to configure the policies. Please make sure that you select the required policies from the drop down as you cannot change them once the certificate is created. As for this certificate, we need the “Digital Signature” selected under “X.509 Key Usage Flags”.



In addition, please check all the flags in order to avoid problems from other features that may be required. You can also select the “Key Size” according to your need.

6. Finally, click “Ok”, and click on create button. This will create the certificate and it will take few minutes for the certificate to enable.


2. Configuring Access to Azure Key-Vault Using Active Directory
In order to use the certificate for signing and verifying the signed data from code we need to be authenticated in order to access the certificate.
In this section let’s understand how to configure an Active Directory app to access the certificate from code.

• Create an Active Directory app

1. Go to “Azure Active Directory” in the azure portal menu.

2. Select “App Registrations”, then click on “New registration” to add a new application providing a meaningful name.


3. Once the app has been created it will appear in the list as below. Copy the Application (Client) ID as it is required in the future.


4. Now navigate into the application details by clicking in the name of the app to generate a client secret. Click on the “Certificates and secrets” and then click on “+ New Client Secret”


Once the client secret is generated copy and have it pasted in a secure place along with the Application (Client) Id

5. Now navigate back to the azure key-vault resource that you created and click on “Access Policies”, then click on “Add Access Policy”.


This will take you to the “Add access policy” page to setup access policies.

Now let’s configure policies.

• From the “Configure from template (optional)”, select the highlighted ones according preference.


• Similarly select the “key permissions”, “secret permissions” and “certificate permissions” accordingly. As in this case it has to be “certificate permissions”.
• From the “Select Principal”, select the name of the Application that we registered with Active Directory. In case the app doesn’t appear in the list, search the name of the application that was used to register with Active Directory.


In this case the name of my Active Directory Application is “CFS-key-vault’. Select the proper application and click on “Add”.

Now this application’s Client-Id and Client-Secret can be used to access the certificate, sign and verify data from code.

3. Connecting to Key-Vault From Code
In this section let’s connect to the azure key-vault using the KeyVaultClient which is in the namespace Microsoft.Azure.KeyVault. The name space is also available as a nuget package at [https://www.nuget.org/packages/Microsoft.Azure.KeyVault/](link url)

Let’s look at the code

public KeyVaultClient GetAzureKeyVaultClientInstance()
       {
           var keyVaultClient = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(AuthenticateClient));
           return keyVaultClient;
       }
 
       private async Task<string> AuthenticateClient(string authority, string resource, string scope)
       {
 
           var clientCredential = new ClientCredential("<your active directory application (client) Id>", "<the client Secret of the active directory app>");
 
           var authenticationContext = new AuthenticationContext(authority);
           var result = await authenticationContext.AcquireTokenAsync(resource, clientCredential);
           return result.AccessToken;
 
       }

• In the above code, the method GetAzureKeyVaultClientInstance(), returns an instance of a KeyVaultClient once the authentication is successful.
• The KeyVaultClient constructor takes in an instance of the KeyVaultClient.AuthenticationCallback() delegate as a constructor parameter which has a callback function AuthenticateClient.
• The private method AuthenticateClient() takes in three arguments as shown in the code.
• You must pass the active directory application client Id and client secret as parameters to the ClientCredential instance as constructor parameters in the private method AuthenticateClient().
• The rest of the code is self-explanatory.
• If the authentication is successful the GetAzureKeyVaultClientInstance() method will return an instance of a KeyVaultClient, else it will throw unauthorized exception.
• Now that we have an instance of the KeyVaultClient, we can use it to sign and verify signed data.

4. Signing and Verifying Signed data using the certificate
In this section lets he how to sign and get the signed data verified using the certificate in azure key-vault.

• Let us first sign data using the certificate.

Let’s walk through the code below

public async Task<ValueTuple<byte[], string, byte[]>> GetSignedResultAsync(string model)
        {
 
            try
            {
                var encodedToBytes = Encoding.UTF8.GetBytes(model);
                var digest = Hasher.GetSHA256Digest(encodedToBytes);
 
                using (var keyVaultClientInstance = azureKeyVaultClient.GetAzureKeyVaultClientInstance())
                {
                    var signedData = await keyVaultClientInstance
                   .SignAsync(keyIdentifier: "<your azure key vault certificate key identifier>", 
algorithm: JsonWebKeySignatureAlgorithm.RS256, digest: digest);
 
                    return (signedData.Result, signedData.Kid, digest);
                }
            }
            catch (Exception e)
            {
                throw new OperationFailedException("some error message");
            }
        }

1. The method GetSignedResultAsync() takes in string parameter which is a JSON serialized representation of the data intended to sign.
2. The serialized JSON is the encoded using the Encoding which is in the namespace System.Text. Here in this example I have used UTF8, you can use other options as well.
3. Then the encodedToByte variable is passed to a hashing function. In this case SHA256 which will return a hashed value which is referred to as a digest.
4. Then in the using statement we can make use of the KeyVaultClient instance that was return after authorization to the azure key-vault. In the above code I have used a function to get an instance of the KeyVaultClient. Since the KeyVaultClient instance implements the IDisposable interface it is wrapped in a using statement.
5. Now on the KeyVaultClient instance we can invoke the SignAsync() method on it.
    The azure key vault key identifier is the identifier of the certificate. You can find the key identifier as shown below.

 Go to you key vault resource. Click on “certificate” in the left blade, then navigate to a certificate you are interested in.


 From here navigate into the certificate version.



• Now, scroll down to the bottom of the page to get the key identifier of the certificate


• The green highlighted area provides key identifier. Copy the key-identifier and past it for the keyIdentifier argument of the SignAsync() of the KeyVaultClient instance.

6. Now, pass the algorithm and digest as the second and third arguments of the SignAsync() method respectively.
7. The SignAsync() will return a KeyOperationResult which has a property Result it. This Result is the DigitalSignature that was signed by the certificate in azure key-vault.


• Now we can verify the digital signature against the original model. Let’s see how.
Lets walk through the code snippet below

public async Task<bool> VerifySignedResultAsync(string algorithm, byte[] digest, byte[] signedResult)
       {
           using (var keyVaultClientInstance = azureKeyVaultClient.GetAzureKeyVaultClientInstance())
           {
               var isVerified = await keyVaultClientInstance
                        .VerifyAsync(keyIdentifier: "<your azure key vault certificate key identifier>", algorithm: algorithm, digest: digest, signature: signedResult);
               return isVerified;
           }
       }

• First, we need an instance of KeyVaultClient class. You can follow the steps explained above to get this done.
• VerifySignedResultAsync() takes in 3 arguments.

1. The first argument is the algorithm. Its mostly the same algorithm which is used to sign the data.
2. The second argument is the digest. The digest is the same as explained above, which is the JSON serialized string hashed using SHA256.
3. The third argument is the DigitalSignature or the signed result.

• The KeyVaultClient instance has a method VerifyAsync() which will take in the arguments passed to the VerifySignedResultAsync() method and the key identifier of the certificate. The VerifyAsync() will return a Boolean true if the signed data and the digest match, else will return false.

That’s it. Hope you have had a better understanding on how to sign and verify signed data and are able to apply to your application when needed.
Thanks.

u can use MS Azure or https://www.smarterasp.net for windows hosting

@akmal , thanks bro

@root will do when i have time

asp core is 18 times faster than node.js

https://www.techempower.com/benchmarks/#section=data-r16&hw=ph&test=fortune

u can use the async await feature in c# to make asynchronus calls

** please note the programing laguage is user preference, do select what is best for the application u start

dotnet core

you can use the express version for free at https://www.microsoft.com/en-us/download/details.aspx?id=42299

@root , here are few links for u to learn what is asp core
https://en.wikipedia.org/wiki/ASP.NET_Core
https://dotnet.microsoft.com/learn/web/what-is-aspnet-core
https://docs.microsoft.com/en-us/aspnet/core/?view=aspnetcore-2.2

community is not a problem brother,u have answers for allmost all problems faced with asp core on the internet

@varuna , if u check the benchmark reports u can find the results brother. some tested application says that node.js made 1000 requests per second while asp core made 20000 requests per second, which is 2000% more

read here https://raygun.com/blog/dotnet-vs-nodejs/

@root ,im a fullstack engineer, i work with pure javascript, typescript and jquery on a daily basis brother, i dont hate js

@root , cheers brother

you can write all your javascripts in on tag.

<script>
function getdoctor(val) {
$.ajax({
type: "POST",
url: "../get_doctor.php",
data:'specilizationid='+val,
success: function(data){
// i assume that your data on ajaxs success has 2 properties in the object
$("#input1").val(data.item1);
$("#input2").val(data.item1);
}
});
}
</script>

how to implement realtime notification in php?

thats great! thanks