The Web API can authenticate the client through an API key with a middleware or an action filter.
Here’s how you can implement a middleware that does that:
public class ApiKeyMiddleware
{
private readonly RequestDelegate _next;
private const string ApiKeyHeaderName = "X-API-KEY";
public ApiKeyMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
if (!context.Request.Headers.TryGetValue(ApiKeyHeaderName, out var potentialApiKey))
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
await context.Response.WriteAsync("Unauthorized");
return;
}
var configuration = context.RequestServices.GetRequiredService<IConfiguration>();
var validApiKey = configuration.GetValue<string>("ApiKey");
if (potentialApiKey != validApiKey)
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
await context.Response.WriteAsync("Forbidden");
return;
}
await _next(context);
}
}
This middleware checks each incoming request for an "X-API-KEY" header. If the header is absent or the key is invalid, it rejects the request with an HTTP 401 or 403 status.
You can use this middleware in your Startup.cs like this:
public void ConfigureServices(IServiceCollection services)
{
// ... other services
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo { Title = "Your API", Version = "v1" });
// Define the BearerAuth scheme
c.AddSecurityDefinition("BearerAuth", new OpenApiSecurityScheme
{
Description = "Input your Bearer token in the following format - Bearer {your token here}",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
Scheme = "BearerAuth"
});
c.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme
{
Reference = new OpenApiReference
{
Type = ReferenceType.SecurityScheme,
Id = "BearerAuth"
},
Scheme = "oauth2",
Name = "BearerAuth",
In = ParameterLocation.Header
},
new List<string>()
}
});
});
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
// ... other middleware
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Your API V1");
c.RoutePrefix = string.Empty;
});
}
In order to receive other custom headers like X-UserName:
public class UserNameMiddleware
{
private readonly RequestDelegate _next;
private const string UserNameHeaderName = "X-AUTH-USERNAME";
public UserNameMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
if (context.Request.Headers.TryGetValue(UserNameHeaderName, out var userName))
{
context.Items[UserNameHeaderName] = userName.ToString();
}
await _next(context);
}
}
Undoing Local Changes That Have Not Been Committed
If you have made changes that you don’t like, and they have not been committed yet, do as follows:
In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
Run git status and you should see the affected file listed.
Run the following command, replacing filename.html with your file path (which you could copy and paste from the git status command):
git checkout filename.html
That file has now been reverted to the way it was at the previous commit (before your changes).
Undoing a Specific Commit (That Has Been Pushed)
If you have one specific commit you want to undo, you can revert it as follows:
In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
Run git status and make sure you have a clean working tree.
Each commit has a unique hash (which looks something like 2f5451f). You need to find the hash for the commit you want to undo. Here are two places you can see the hash for commits:
In the commit history on the GitHub or Bitbucket or website.
In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log –oneline
Once you know the hash for the commit you want to undo, run the following command (replacing 2f5451f with your commit’s hash):
git revert 2f5451f –no-edit
NOTE: The –no-edit option prevents git from asking you to enter in a commit message. If you don’t add that option, you’ll end up in the VIM text editor. To exit VIM, press : to enter command mode, then q for quit, and finally hit Return (Mac) or Enter (Windows).
This will make a new commit that is the opposite of the existing commit, reverting the file(s) to their previous state as if it was never changed.
If working with a remote repo, you can now push those changes:
git push
Undoing Your Last Commit (That Has Not Been Pushed)
If you made a mistake on your last commit and have not pushed yet, you can undo it. For example, maybe you added some files and made a commit, and then immediately realized you forgot something. You can undo the commit, and then make a new (correct) commit. This will keep your history cleaner.
In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
Run this command:
git reset –soft HEAD~
TIP: Add a number to the end to undo multiple commits. For example, to undo the last 2 commits (assuming both have not been pushed) run git reset –soft HEAD~2
NOTE: git reset –soft HEAD~ is the same as git reset –soft HEAD^ which you may see in Git documentation.
Your latest commit will now be undone. Your changes remain in place, and the files go back to being staged (e.g. with git add) so you can make any additional changes or add any missing files. You can then make a new commit.
Undoing Local Changes That Have Been Committed (But Not Pushed)
If you have made local commits that you don’t like, and they have not been pushed yet you can reset things back to a previous good commit. It will be as if the bad commits never happened. Here’s how:
In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
Run git status and make sure you have a clean working tree.
Each commit has a unique hash (which looks something like 2f5451f). You need to find the hash for the last good commit (the one you want to revert back to). Here are two places you can see the hash for commits:
In the commit history on the GitHub or Bitbucket or website.
In your terminal (Terminal, Git Bash, or Windows Command Prompt) run the command git log –oneline
Once you know the hash for the last good commit (the one you want to revert back to), run the following command (replacing 2f5451f with your commit’s hash):
git reset 2f5451f
git reset –hard 2f5451f
NOTE: If you do git reset the commits will be removed, but the changes will appear as uncommitted, giving you access to the code. This is the safest option, because maybe you wanted some of that code and you can now make changes and new commits that are good. Often though you’ll want to undo the commits and through away the code, which is what git reset –hard does.
Generating public/private ed25519 key pair.
Enter file in which to save the key (/Users/<xxxxx>/.ssh/<yyyy>): /Users/<xxxxx>/.ssh/github_id
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/<xxxxx>/.ssh/github_id
Your public key has been saved in /Users/<xxxxx>/.ssh/github_id.pub
The key fingerprint is:
.....
The key's randomart image is:
+--[ED25519 256]--+
| .. .=.. |
| .o ..S.. |
| .. ..o. . .|
| . o. ..o . . o |
| =+...S = . + |
| oS.++ o + . |
| o+.+ . o |
| o.. . . |
| o..E |
+----[SHA256]-----+
go to https://github.com/settings/keys
click to New SSH Key
write a title, select Authentication Key, copy content of <yyyy>.pub file to the Key area
declare @sql nvarchar(max);
select @sql =
(select ' UNION ALL
SELECT ' + + quotename(name,'''') + ' as database_name,
s.name COLLATE DATABASE_DEFAULT
AS schema_name,
t.name COLLATE DATABASE_DEFAULT as table_name
FROM '+ quotename(name) + '.sys.tables t
JOIN '+ quotename(name) + '.sys.schemas s
on s.schema_id = t.schema_id
WHERE t.name =''table_name'''
from sys.databases
where state=0
order by [name] for xml path(''), type).value('.', 'nvarchar(max)');
set @sql = stuff(@sql, 1, 12, '') + ' order by database_name,
schema_name,
table_name';
execute (@sql);
select * from sys.sysprocesses where status = 'SLEEPING' and open_tran > 0
-------
declare @sp int
select @sp = spid from sys.sysprocesses where status = 'SLEEPING' and open_tran > 0
if @sp is not null
begin
declare @tempString nvarchar (255)
set @tempString = 'kill ' + cast (@sp as varchar (5))
exec sp_executesql @tempString
end
This command sets the author name and email address respectively to be used with your commits.
git init
Usage: git init [repository name]
This command is used to start a new repository.
git clone
Usage: git clone [url]
This command is used to obtain a repository from an existing URL.
git add
Usage: git add [file]
This command adds a file to the staging area.
Usage: git add .
This command adds one or more to the staging area.
git commit
Usage: git commit -m “[ Type in the commit message]”
This command records or snapshots the file permanently in the version history.
Usage: git commit -a
This command commits any files you’ve added with the git add command and also commits any files you’ve changed since then.
git diff
Usage: git diff
This command shows the file differences which are not yet staged.
Usage: git diff –staged
This command shows the differences between the files in the staging area and the latest version present.
Usage: git diff [first branch] [second branch]
This command shows the differences between the two branches mentioned.
git reset
Usage: git reset [file]
This command unstages the file, but it preserves the file contents.
Usage: git reset [commit]
This command undoes all the commits after the specified commit and preserves the changes locally.
Usage: git reset –hard [commit] This command discards all history and goes back to the specified commit.
git status
Usage: git status
This command lists all the files that have to be committed.
git rm
Usage: git rm [file]
This command deletes the file from your working directory and stages the deletion.
git log
Usage: git log
This command is used to list the version history for the current branch.
Usage: git log –follow[file]
This command lists version history for a file, including the renaming of files also.
git show
Usage: git show [commit]
This command shows the metadata and content changes of the specified commit.
git tag
Usage: git tag [commitID]
This command is used to give tags to the specified commit.
git branch
Usage: git branch
This command lists all the local branches in the current repository.
Usage: git branch [branch name]
This command creates a new branch.
Usage: git branch -d [branch name]
This command deletes the feature branch.
git checkout
Usage: git checkout [branch name]
This command is used to switch from one branch to another.
Usage: git checkout -b [branch name]
This command creates a new branch and also switches to it.
git merge
Usage: git merge [branch name]
This command merges the specified branch’s history into the current branch.
git remote
Usage: git remote add [variable name] [Remote Server Link]
This command is used to connect your local repository to the remote server.
git remote -v
This command is used to show all remotes.
git push
Usage: git push [variable name] master
This command sends the committed changes of master branch to your remote repository.
Usage: git push [variable name] [branch]
This command sends the branch commits to your remote repository.
Usage: git push –all [variable name]
This command pushes all branches to your remote repository.
Usage: git push [variable name] :[branch name]
This command deletes a branch on your remote repository.
git pull
Usage: git pull [Repository Link]
This command fetches and merges changes on the remote server to your working directory.
git stash
Usage: git stash save
This command temporarily stores all the modified tracked files.
Usage: git stash pop
This command restores the most recently stashed files.
Usage: git stash list
This command lists all stashed changesets.
Usage: git stash drop
This command discards the most recently stashed changeset.
Treeish and Hashes
Rather than a sequential revision ID, Git marks each commit with a SHA-1 hash that is unique to the person committing the changes, the folders, and the files comprising the changeset. This allows commits to be made independent of any central coordinating server.
A full SHA-1 hash is 40 hex characters: b0c2c709cf57f3fa6e92ab249427726b7a82d221
To efficiently navigate the history of hashes, several symbolic shorthand notations can be used as listed in the table below. Additionally, any unique sub-portion of the hash can be used. Git will let you know when the characters supplied are not enough to be unique. In most cases, 4-5 characters are sufficient.
TREEISH
DEFINITION
HEAD
The current committed version
HEAD^, HEAD~1
One commit ago
HEAD^^, HEAD~2
Two commits ago
HEAD~N
N commits ago
RELEASE-1.0
User defined tag applied to the code when it was certified for release
The complete set of revision specifications can be viewed by typing:
git help rev-parse
Treeish can be used in combination with all Git commands that accept a specific commit or range of commits.
Daily work calls for strong support of viewing current and historical facts about your repository, often from different, perhaps even orthogonal points of view. Git satisfies those demands in spades.
Status
To check the current status of a project’s local directories and files (modified, new, deleted, or untracked) invoke the status command:
git status
Diff
A patch-style view of the difference between the currently edited and committed files, or any two points in the past can easily be summoned. The .. operator signifies a range is being provided. An omitted second element in the range implies a destination of the current committed state, also known as HEAD:
git diff
git diff 32d4
git diff --summary 32d4..
Depending on the Git distribution, a utility called diff-highlight will be included to make diffs easier to visualize by highlighting word-level diffs instead of the default line level changes. Make sure diff-highlight is available in your $PATH and enable it with:
git config --global core.pager "diff-highlight | less -r"
Git allows for diffing between the local files, the stage files, and the committed files with a great deal of precision.
COMMAND
DEFINITION
git diff
Everything unstaged (not git add’ed) diffed to the last commit
git diff –cached
Everything staged (git add’ed) diffed to the last commit
git diff HEAD
Everything unstaged and staged diffed to the last commit
Log
The full list of changes since the beginning of time, or optionally, since a certain date is right at your fingertips, even when disconnected from all networks:
If trying to discover why and when a certain line was added, cut to the chase and have Git annotate each line of a source file with the name and date it was last modified: