Git: undo changes

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:

  1. In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
  2. Run git status and you should see the affected file listed.
  3. 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
  4. 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:

  1. In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
  2. Run git status and make sure you have a clean working tree.
  3. 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
  4. 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).
  5. 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.
  6. 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.

  1. In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
  2. 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.
  3. 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:

  1. In your terminal (Terminal, Git Bash, or Windows Command Prompt), navigate to the folder for your Git repo.
  2. Run git status and make sure you have a clean working tree.
  3. 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
  4. 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.

Access SQL queries Generated By Entity Framework Core 3

Create a class EntityFrameworkSqlLogger.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using Microsoft.Extensions.Logging;

namespace MyApp.Logging
{
    /// <summary>
    /// ILogger implementation
    /// </summary>
    public class EntityFrameworkSqlLogger : ILogger
    {
        #region Fields
        Action<EntityFrameworkSqlLogMessage> _logMessage;
        #endregion

        #region Constructor
        public EntityFrameworkSqlLogger(Action<EntityFrameworkSqlLogMessage> logMessage)
        {
            _logMessage = logMessage;
        }
        #endregion

        #region Implementation
        public IDisposable BeginScope<TState>(TState state)
        {
            return default;
        }

        public bool IsEnabled(LogLevel logLevel)
        {
            return true;
        }

        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            if (eventId.Id != 20101)
            {
                //Filter messages that aren't relevant.
                //There may be other types of messages that are relevant for other database platforms...

                return;
            }

            if (state is IReadOnlyList<KeyValuePair<string, object>> keyValuePairList)
            {
                var entityFrameworkSqlLogMessage = new EntityFrameworkSqlLogMessage
                (
                    eventId,
                    (string)keyValuePairList.FirstOrDefault(k => k.Key == "commandText").Value,
                    (string)keyValuePairList.FirstOrDefault(k => k.Key == "parameters").Value,
                    (CommandType)keyValuePairList.FirstOrDefault(k => k.Key == "commandType").Value,
                    (int)keyValuePairList.FirstOrDefault(k => k.Key == "commandTimeout").Value,
                    (string)keyValuePairList.FirstOrDefault(k => k.Key == "elapsed").Value
                );

                _logMessage(entityFrameworkSqlLogMessage);
            }
        }
        #endregion
    }
    
    /// <summary>
    /// Data model
    /// </summary>
    public class EntityFrameworkSqlLogMessage
    {
        public EntityFrameworkSqlLogMessage(
            EventId eventId,
            string commandText,
            string parameters,
            CommandType commandType,
            int commandTimeout,
            string elapsed
        )
        {
            EventId = eventId;
            CommandText = commandText;
            Parameters = parameters;
            CommandType = commandType;
            Elapsed = elapsed;
            CommandTimeout = commandTimeout;
        }

        public string Elapsed { get; }
        public int CommandTimeout { get; }
        public EventId EventId { get; }
        public string CommandText { get; }
        public string Parameters { get; }
        public CommandType CommandType { get; }
    }
    
    /// <summary>
    /// ILogger provider
    /// </summary>
    public class SingletonLoggerProvider : ILoggerProvider
    {
        #region Fields
        ILogger _logger;
        #endregion

        #region Constructor
        public SingletonLoggerProvider(ILogger logger)
        {
            _logger = logger;
        }
        #endregion

        #region Implementation
        public ILogger CreateLogger(string categoryName)
        {
            return _logger;
        }

        public void Dispose()
        {
        }
        #endregion
    }
}

Add Logger to DbContext OnConfiguring Met

public class CartServiceDbContext : DbContext
{
...

  protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
  {
      var entityFrameworkSqlLogger = new EntityFrameworkSqlLogger((m) =>
      {
          System.Console.WriteLine($"SQL Query:\r\n{m.CommandText}\r\nElapsed:{m.Elapsed} millisecods\r\n\r\n");
      });

      var myLoggerFactory = LoggerFactory.Create(builder =>
      {
          builder
              .AddFilter((category, level) =>
                  category == DbLoggerCategory.Database.Command.Name
                  && level == LogLevel.Information);
      });

      myLoggerFactory.AddProvider(new SingletonLoggerProvider(entityFrameworkSqlLogger));
      optionsBuilder.UseLoggerFactory(myLoggerFactory);
      DbConnectorUtils.ConfigureOptionsBuilder(optionsBuilder);
  }

...
}

References

ssh Github

Mac from Terminal

ssh-keygen -t ed25519 -C "yourmail@domain.com"

output:

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

Search for a table in all databases in a SQL Server instance

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

Find and Kill SQL Server orphaned transactions


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

Git main commands

git config

Usage: git config –global user.name “[name]”  

Usage: git config –global user.email “[email address]”  

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.

TREEISHDEFINITION
HEADThe current committed version
HEAD^, HEAD~1One commit ago
HEAD^^, HEAD~2Two commits ago
HEAD~NN commits ago
RELEASE-1.0User 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.

Examples include:

git log HEAD~3..HEAD

git checkout HEAD^^

git merge RELEASE-1.0 

git diff HEAD^..

Viewing

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.

COMMANDDEFINITION
git diffEverything unstaged (not git add’ed) diffed to the last commit
git diff –cachedEverything staged (git add’ed) diffed to the last commit
git diff HEADEverything 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:

git log
git log --since=yesterday $ git log --since=2weeks

Blame

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:

git blame <filename.ext>

Best way to use HttpClient

// in Program.cs
builder.Services.AddSingleton<IWeatherClient, OpenWeatherClient>();
builder.Services.AddHttpClient("openWeatherApi", client =>
{
    client.BaseAddress = new Uri("https://api.openweathermap.org/data/2.5/");
});

// in OpenWeatherClient.cs
public class OpenWeatherClient : IWeatherClient
{
    private const string OpenWeatherMapApiKey = "";
    private readonly IHttpClientFactory _httpClientFactory;

    public OpenWeatherClient(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    public async Task<WeatherResponse?> GetCurrentWeatherForCity(string city)
    {
        var client = _httpClientFactory.CreateClient("openWeatherApi");
        return await client.GetFromJsonAsync<WeatherResponse>(
            $"weather?q={city}&appid={OpenWeatherMapApiKey}");
    }
}
// in Program.cs
 builder.Services.AddHttpClient<IWeatherClient, OpenWeatherClient>(client =>
 {
     client.BaseAddress = new Uri("https://api.openweathermap.org/data/2.5/");
 });

// in OpenWeatherClient.cs
public class OpenWeatherClient : IWeatherClient
{
    private const string OpenWeatherMapApiKey = "";
    private readonly HttpClient _httpClient;

    public OpenWeatherClientSecond(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<WeatherResponse?> GetCurrentWeatherForCity(string city)
    {
        return await _httpClient.GetFromJsonAsync<WeatherResponse>(
            $"weather?q={city}&appid={OpenWeatherMapApiKey}");
    }
}

C# From String to Stream, and From Stream to String

static void Main( string[] args )
{
    string test = "My sample text";

    // convert string to stream
    byte[] byteArray = Encoding.ASCII.GetBytes( test );
    MemoryStream stream = new MemoryStream( byteArray ); 

    // convert stream to string
    StreamReader reader = new StreamReader( stream );
    string text = reader.ReadToEnd();

    Console.WriteLine( text );
    Console.ReadLine();
}
static void Main( string[] args )
{
    string test = "My sample text";

    // convert string to stream
    MemoryStream stream = new MemoryStream();
    StreamWriter writer = new StreamWriter( stream );
    writer.Write( test );
    writer.Flush();

    // convert stream to string
    stream.Position = 0;
    StreamReader reader = new StreamReader( stream );
    string text = reader.ReadToEnd();
}

Oh My Posh | Oh My Zsh

Oh My Posh

Windows

Official website: https://ohmyposh.dev/

NerdFonts: https://www.nerdfonts.com/font-downloads

Installation (https://www.hanselman.com/blog/my-ultimate-powershell-prompt-with-oh-my-posh-and-the-windows-terminal)


Install-Module -Name Terminal-Icons -Repository PSGallery
Install-Module -Name oh-my-posh -RequiredVersion 6.17.0
Get-Module oh-my-posh
Import-Module oh-my-posh
oh-my-posh --init --shell pwsh --config jandedobbleer.omp.json | Invoke-Expression

Microsoft.PowerShell_profile.ps1

Import-Module -Name Terminal-Icons
Import-Module oh-my-posh
cd Powershell/Modules/oh-my-posh
./oh-my-posh --init --shell pwsh --config C:\Users\...\PowerShell\Modules\oh-my-posh\6.17.0\themes\ohmyposhv3-v2.json | Invoke-Expression

MacOs

taken from https://ohmyposh.dev/docs/installation/macos

  • install oh-my-posh with brew
% brew install jandedobbeleer/oh-my-posh/oh-my-posh
% chmod 755 install-nerd-fonts.sh
% install-nerd-fonts.sh
  • run bash with preferred theme
% oh-my-posh prompt init [bash|zsh|fish|powershell|pwsh|cmd|nu] --config ~/.mytheme.omp.json [flags]

------- or ----------

% eval "$(oh-my-posh init bash --config /usr/local/opt/oh-my-posh/themes/atomic.omp.json)"

------- or ----------

% cd $(brew --prefix oh-my-posh)/themes
% eval "$(oh-my-posh init bash --config atomic.omp.json)"

------- or zsh ----------

% eval "$(oh-my-posh init zsh --config /usr/local/opt/oh-my-posh/themes/atomic.omp.json)"

------- or ----------

% eval "$(oh-my-posh init zsh --config ~/.jandedobbeleer.omp.json)"
  • put the command in the .zshrc file

Oh My Zsh

Go to https://ohmyz.sh/ where you can find all instructions:

sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Install zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

Linq Grouping examples

I have a collection of items, here it is:

AgencyID VendorID StateID Amount Fee
1        1        1       20.00  5.00
1        1        1       10.00  2.00
1        1        1       30.00  8.00    
2        2        1       20.00  5.00
2        2        1       5.00   5.00
1        1        2       20.00  5.00
2        2        2       20.00  5.00
2        2        2       40.00  9.00
1        2        2       35.00  6.00
1        2        2       12.00  3.00

I’d like these items to be grouped based on the AgencyID, VendorID, and StateID, and the Total calculated from Amount and Fee (Amount + Fee)

So using the data above, I’d like to have these results:

AgencyID VendorID StateID Total
1        1        1       75.00    
2        2        1       35.00
1        1        2       25.00
2        2        2       74.00
1        2        2       56.00
var agencyContracts = _agencyContractsRepository.AgencyContracts
    .GroupBy(ac => new
                   {
                       ac.AgencyContractID, // required by your view model. should be omited
                                            // in most cases because group by primary key
                                            // makes no sense.
                       ac.AgencyID,
                       ac.VendorID,
                       ac.RegionID
                   })
    .Select(ac => new AgencyContractViewModel
                   {
                       AgencyContractID = ac.Key.AgencyContractID,
                       AgencyId = ac.Key.AgencyID,
                       VendorId = ac.Key.VendorID,
                       RegionId = ac.Key.RegionID,
                       Amount = ac.Sum(acs => acs.Amount),
                       Fee = ac.Sum(acs => acs.Fee)
                   });

Second Example

public class ConsolidatedChild
{
    public string School { get; set; }
    public string Friend { get; set; }
    public string FavoriteColor { get; set; }
    public List<Child> Children { get; set; }
}

public class Child
{
    public string School { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
    public string Friend { get; set; }
    public string Mother { get; set; }
    public string FavoriteColor { get; set; }
}
var consolidatedChildren =
    from c in children
    group c by new
    {
        c.School,
        c.Friend,
        c.FavoriteColor,
    } into gcs
    select new ConsolidatedChild()
    {
        School = gcs.Key.School,
        Friend = gcs.Key.Friend,
        FavoriteColor = gcs.Key.FavoriteColor,
        Children = gcs.ToList(),
    };

var consolidatedChildren =
    children
        .GroupBy(c => new
        {
            c.School,
            c.Friend,
            c.FavoriteColor,
        })
        .Select(gcs => new ConsolidatedChild()
        {
            School = gcs.Key.School,
            Friend = gcs.Key.Friend,
            FavoriteColor = gcs.Key.FavoriteColor,
            Children = gcs.ToList(),
        });