DEV Community: Jakub Rumpel

Adding specific certificate to HttpClient in .NET 6

Jakub Rumpel — Wed, 31 Aug 2022 09:34:58 +0000

For the last few days, I was dealing with an issue that wouldn't let me rest. My job requires me to use smartcard to authorize access to some of the internal services. That's not a problem when I use a browser like Chrome or Firefox, but becomes an issue when I want to use these services through their API to automate something really boring.

Of course, the smartcard itself only serves the purpose of authorizing usage of the certificate that's already installed off of it in my personal certificate store on Windows, but I still have to somehow add it to my request.

Required steps, then:

Access the certificate store
Find my certificate
Add it to the HttpClient
Successfully perform a request

Seems simple enough, so let's get to it. First, I have to access my personal certificate store:

var store = new X509Store(StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadOnly);

These two lines first create an object to access a personal store of a current user, and then open it in ReadOnly mode. We don't need the right to change anything, so ReadOnly will suffice.
Now, let's find our certificate. In my example, the easiest way is to use the IssuerName, because there is only one with this specific name. In yours, you might want to find another property that suits you better:

var certificate = store.Certificates.First(cert => cert.IssuerName.Name == "ISSUER_NAME");

This line finds the first certificate with IssuerName that fits our requirements. Now that we have it, let's add it to the client.
In order to do that, we first have to create an HttpClientHandler(), which will then be used to create an HttpClient() object.

var clientHandler = new HttpClientHandler();
clientHandler.ClientCertificates.Add(certificate);
var client = new HttpClient(clientHandler);

As you can see, between creating a Handler and using it to create a Client, we added the certificate to it. Now we don't have to worry about it anymore, because the Client will use it by default.
The rest of the work is to perform a request in a standard manner:

client.BaseAddress = new Uri("https://service.service");
var result = await client.GetAsync("/endpoint");

This request will use our added certificate to authorize itself with a service, and everything should work just fine. The problem is solved, and now I can automate my really boring tasks - and so can you ;)

This article was first published on my personal blog https://rumpel.dev

Git can cause problems with vim-plug!

Jakub Rumpel — Fri, 20 May 2022 14:45:10 +0000

Or rather, bad configuration can do it.

See, I’ve just spent about an hour trying to figure this out, and for the life of me I couldn’t understand, what was happening.

I’ve recently fallen in love with the idea of adding new features to Vim using plugins. As I have four different machines running Linux in one way or another, I have decided to install the same two plugins (Ale and NerdTree) on all of them. Sounds simple enough, doesn’t it? And it was really simple!

On three out of four machines it worked perfectly. One command to install plug-vim on machine, copy the right section into my .vimrc… simple enough, it worked. Right until I tried to install it on my fourth, final and most important machine: Ubuntu in WSL2 on my personal laptop.

For reasons unknown to me at the time, every time I’ve tried to install plugins, I just got these errors:

Error detected while processing /home/hane/.vim/plugged/nerdtree/plugin/NERD_tree.vim:
line 15:
E492: Not an editor command: ^M
line 16:
E15: Invalid expression: exists('loaded_nerd_tree')^M
line 235:
E171: Missing :endif
Error detected while processing /home/hane/.vim/plugged/ale/plugin/ale.vim:
line 4:
E492: Not an editor command: ^M
line 6:
E492: Not an editor command: ^M
line 7:
E15: Invalid expression: exists('g:loaded_ale_dont_use_this_in_other_plugins_please')^M
line 353:
E171: Missing :endif
Press ENTER or type command to continue

They showed up every time I opened Vim, too, so nothing too pleasant.

The culprit was good ol’ Git.

It took me more than an hour to find the right way to google this, and kudos to this specific comment for helping me!

The fix was simple: Change git configuration and set property core.autocrlf to false.

One command:

git config --global core.autocrlf false

And after reinstalling plugins once again, all my problems were gone!

So what happened?

Vim-plug uses git to download plugins. When core.autocrlf was set to true , it automatically set line endings for every file to CRLF, while Vim, when processing .vim files on Linux, was expecting LF endings. That caused the problem above:

E492: Not an editor command: ^M

But what is an ^M, and what does it have to do with Line Endings?

^M is a CR in CRLF, which stands for Carriage Return. It’s a control character used to move a cursor to the beginning of the next line when reaching the end of a current line. As you can probably guess, it was not expected in this case, because only ^@ (Line Feed, LF in CRLF) was expected by Vim and the end of the line.

So Vim got one more character than expected and wasn’t ready to process it, effectively being unable to run installed plugins.

Of course, I could’ve spent much less time on fixing that, if I knew what ^M was beforehand, but hey - We’re all learning, right?

If you encountered this issue too, and this article helped you, please let me know!

This article was originally posted on my personal website Rumpel.dev. You can find more posts and informations about me there!

Code stupid things

Jakub Rumpel — Wed, 26 Jan 2022 04:48:25 +0000

Today I’ve watched new video from CodeBullet: Channel that I found when I had a huge phase on watching everything AI - be it teaching a neural network to play a Mario game or drive a simple car... anything like that, and CodeBullet provided me with exactly such a material: simple or not so simple task with an interesting enough narration.

The video was about creating a simple program to cheat in “Clicker Heroes” game. While I don’t know this game, and didn’t want to download it, it reminded me a little bit of an old in-browser clicker game called “Cookie Clicker”. There was a time when I spent too much time there, so I was happy to notice it’s still up and online as of writing this post.

What is this about, really?

After finding the game again I realized that I’m curious about my ability to code something like this: simple clicker to cheat the game, as a fun project. 3 AM be damned, I took a laptop and started coding. Finding whether I was in a game, clicking a cookie, check for upgrades and buying them... all of that in a language I didn’t touch in a long while: Python.

Two and a half hours later, and the code - as simple and unpolished as it is - is done and working. Cookies are clicked, upgrades are being bought and I can watch and smile, as I see my code working without problems.

And then I remembered.

Coding used to be really fun for me. Such small projects, just to achieve simple objective, overcome a simple challenge. For the last two and a half years of my professional career, I stopped coding just for fun. Projects like this weren’t really in my head, while I had to focus on building my independent life which I’ve then just begun and code I was working on at any company I was currently working at.

My point is, I forgot that I’ve got into coding to have fun; To overcome those little challenges, to see my work come to any kind of fruition. Of course, there were other sources of motivation, biggest of which was my desire to make people’s life easier using what I have learned, but this? This is where it all started. Simple pleasure from fulfilling a simple task using code.

Remember to code small, stupid things.

It’s just never boring. There is always something you can do to just... do a thing. Some stupid challenge, like making your computer react to you in some way. Or any kind of automation, like turning off your console at the specified time in case you left it in rest mode. Or anything else that will probably take you less then two hours, but will flood your brain with dopamine. My point is, remember that coding, like any other work, can be used both professionally and just for fun, for the simple pleasure of Doing The Thing. If you can make your life easier while you do that, it’s just gravy.

Just remember to have fun.

PS. For those curious, you can find the code I wrote here. Word of warning: It’s not pretty or polished, I’m not a daily Python developer. It was just the easiest language to quickly achieve this objective, and I like writing simple scripts of this kind in Python.

Setting up a .NET service on Linux

Jakub Rumpel — Tue, 11 May 2021 20:58:23 +0000

This is another "I don't want to have to google this anymore" kind of post.

Quick sidenotes:

I use .NET 5
I didn't create the example .service file; I couldn't find the original author, as it probably was from Stack Overflow, but this is the file I use on my VPS.
This completely doesn't cover setting up nginx or writing actual code - just creates a service which runs your .NET app

Create .service file

My .service files are stored in /etc/systemd/system/

Sample .service file:

[Unit]
Description=Sample Description

[Service]
# systemd will run this executable to start the service, has to be specific file
ExecStart=/srv/AppDir/AppExecutable

# to query logs using journalctl, set a logical name here
SysLogIdentifier=SampleName

# use your username to keep things simple
#make use user you chose has the correct permissions to run the app
User=username

#this environment variable is neccessary when dotnet isn't loadeed for the specified user. 
#to figure out this variable, run 'env | grep DOTNET_ROOT' when dotnet has been loaded into your shell
#Environment="DOTNET_ROOT=/opt/rh/rh-dotnet31/root/usr/lib64/dotnet"

[Install]
WantedBy=multi-user.target

Description - this will be shown as a description when you run systemctl status ServiceName.service, useful in order to identify the service
ExecStart - This has to be a direct path to the executable file of your app. Make sure you made it executable using chmod +x!
SysLogIdentifier - Name of the app used in syslog - again, useful to identify your app later
User - Username of the user who "runs" the app. Preferably use your own, but you can use any as long as specified user has the correct permissions

Register the service

First, check if systemctl command properly sees your .service file:
```
sudo systemctl status ServiceName.service
```
If results seems okay (Description is shown, and it seems like everything is okay), start your service
```
sudo systemctl start ServiceName.service
```

Aaand that's it! From this point on, you just have to make sure your code is good, and test if your app works!

Have a great day ;)

Be careful using ROLLBACK on nested transaction in SQL Server!

Jakub Rumpel — Mon, 10 May 2021 13:52:09 +0000

This is something I've learned today, and was pretty irritated to find out.

Up to this day I was sure that ROLLBACK TRANSACTION in nested transactions will only roll back highest, most recent transaction. To my surprise, something else happens. Consider following example:

BEGIN TRAN
    BEGIN TRAN
    ROLLBACK TRAN
COMMIT TRAN

Do you know what will happen?

First and second transaction will be created
BOTH First and second transaction will be rolled back
A "The COMMIT TRANSACTION request has no corresponding BEGIN TRANSACTION." error will be thrown.

This is a warning: Be careful when rolling back nested transactions. It doesn't matter if transactions are named or how many are there - ROLLBACK will roll back all of them.

When do you use nested transactions?

The easiest example I can think of is when you call a procedure from a different procedure, and you have transactions in both those procedures:

--this is a very simplified example
CREATE PROCEDURE Proc1 AS
BEGIN
    BEGIN TRAN
        EXEC Proc2
    COMMIT TRAN
END

CREATE PROCEDURE Proc2 AS
BEGIN
    BEGIN TRAN
    ROLLBACK TRAN
END

As you can see, there are two nested transactions here, and both will be rolled back because of ROLLBACK TRAN statement in Proc2, leading to an error being thrown when we get to COMMIT TRAN statement.

How can you avoid the error message?

There are two ways I find most likely to be useful:

Check @@trancount before committing transaction

This is simple enough: When you get to committing all the changes you've made in the transaction, check if there are still transactions left to be committed. Check the following code:
```
--this is a very simplified example
CREATE PROCEDURE Proc1 AS
BEGIN
    BEGIN TRAN
        EXEC Proc2
    IF(@@trancount > 0)
    BEGIN
        COMMIT TRAN
    END
END

CREATE PROCEDURE Proc2 AS
BEGIN
    BEGIN TRAN
    ROLLBACK TRAN
END
```
With this newly added IF in Proc1, the COMMIT statement won't be called, because there will be no transactions left to commit detected by our condition.
Use only one rollback in CATCH statement

Sometimes you can avoid such problem by removing transaction from nested procedure, and instead using RAISERRROR and BEGIN TRY/BEGIN CATCH statements. Check the following code:
```
CREATE PROCEDURE Proc1 AS
BEGIN
    BEGIN TRY
        BEGIN TRAN
            EXEC Proc2
        COMMIT TRAN
    END TRY
    BEGIN CATCH
        ROLLBACK TRAN
    END CATCH
END

CREATE PROCEDURE Proc2 AS
BEGIN
    RAISERROR('Sample error', 16, 1) --numbers are examples for severity and state
END
```
In this example, rollback will only happen when there will be and error in Proc2 - leading to a situation when we have one master transaction, which can be rolled by only by throwing an error. Of course, we can also roll it back earlier and handle such a case however we see fit. This is just an example of how you can avoid problems with rolling back a nested transaction.

Sidenotes:

I'm aware that in new applications THROW is preferred to RAISERROR, but sadly I haven't used it yet, so I decided to use old statement for now
This post completely ignores the existence of XACT_ABORT and XACT_STATE - you can learn more about those under provided links. I encourage you to do so: They can make managing your transactions much easier.

Summary

Be careful when rolling back nested transactions
ROLLBACK statement always rolls back every transaction you have in your current session.
You can deal with lack of transactions by checking for @@trancount or removing nested transactions and using RAISERROR or THROW

Transactions in SQL Server are still a difficult subject for me, so if I made any mistake, please, let me know!

Quick-start SQL Server 2019 in Docker

Jakub Rumpel — Sun, 25 Apr 2021 17:04:07 +0000

It's not any kind of magic, but every time I have to do it, I find myself googling for the exact command again and again, So I decided to just save it here - for me, later, and for anyone else who want to paste a command into the terminal and be done with it.

I assume that you already have Docker installed, but in case you don't, there is a great tutorial for Windows here, or for Ubuntu here on how to do it.

docker run -e "ACCEPT_EULA=Y" -e "SA_PASSWORD=<YourStrong@Passw0rd>" \
   -p 1433:1433 --name YourContainerName -h ContainerHostname \
   -d mcr.microsoft.com/mssql/server:2019-latest

If you need any additional information, check out this page for details about arguments and passed values.

REMEMBER: Password has to be compliant with SQL Server default password policy:

By default, the password must be at least 8 characters long and contain characters from three of the following four sets: Uppercase letters, Lowercase letters, Base 10 digits, and Symbols

To check if your container works properly, see it's status using this command:

docker ps

If you can't see it, run it with "-a" argument to see if it's shut down.

docker ps -a

If you have any trouble starting the image, you can see container log by running this command:

docker logs YourContainerName

Avoid SQL Server scalar-valued functions in WHERE statements at all cost!

Jakub Rumpel — Fri, 23 Apr 2021 19:01:41 +0000

This one requires a little intro.

First, you have to understand what a scalar value does: It returns a single value. It can be an INT, a BIT or even a whole NVARCHAR with hundreds of characters, but it will return only one full value, and never a set of them. If you need a set of values, use table functions.

Secondly, there is a certain order to SQL queries that you have to know about. More info about this order and exceptions from it can be found here, but the short lesson is that if you have a SELECT FROM WHERE query, the order of operations will be:

FROM
WHERE
SELECT

That means that SQL Server will first grab all possible records from chosen tables, then filter them using your conditions, and then show you the result.

Third and final intro information Scalar-valued functions in WHERE statements work ONCE for every row.

They work ONCE per ROW. Let that sink in, understand what it means.

If your FROM statement grabs, say, 200 records, it will run a function 200 times. If it'll grab 500,000 records, that's how many times a function will run, for every single row of data you grabbed. And remember: Not just those you SELECTed, but every single cell possible.

You might say "but my function only runs for a millisecond!", and you might even be right. But 500,000 times one millisecond is 500 seconds, so give or take 8 minutes.

Let that sink in.

My advice? Avoid them at all cost. But what if you have to use a scalar-valued function in WHERE statement? What if you think you can't live without it? Say, for example, that your user can only see some records on your table, while others shouldn't show up on the interface, and your function is something along the lines of Has_Permition(User_Id, Item_Id).

--Assume that @User_Id is declared eariler, as a procedure argument or variable
SELECT 
    Item_Id,
    Item_Name
    Item_Description
FROM 
    Items
WHERE
    Has_Permission(@User_Id, Item_Id) = 1

What then? I've identified at least two possible solutions.

One: Inline your function content into query

This isn't really intuitive, but if you do it, you make sure that your records are processed in bulk.

SELECT 
    Item_Id,
    Item_Name
    Item_Description
FROM 
    Items AS I
WHERE
    EXISTS 
    (
            SELECT TOP 1 1
            FROM 
                ItemCategoryPermissions AS ICP
                JOIN Permissions AS P ON P.Id = ICP.Permission_Id
                JOIN UserPermissions AS UP ON UP.Permission_Id = P.Id
            WHERE
                ICP.Category_Id = I.Category_Id
                AND UP.User_Id = @User_Id
    )

Let's stop here for a second and analyze this query.

Instead of checking every single Item_Id in Has_Permission, which, depending on the number of items, could take forever, and check every item at once in this kind of bulk query.

Now, I get why one would want to avoid that, because it defies the basic idea of using functions in programming - to avoid code repetitions. However, in SQL sometimes it's better to write code like this in the name of performance. Of course, it depends on the specific case: If it's part of a job running once a day, you might care less for performance, and more for nice, maintainable code. However, if you're running a stored procedure straight from user-facing interface, to show someone a table filled with data, performance is a top priority - and this is how you can achieve it.

Two: Minimize number of records processed through function.

You can achieve this in many ways, but there are two main ones I lean to.

First, and the one I prefer, is to use a Common Table Expression, or CTE for short, and get only records that are relevant for this specific search. For example, if your search window only look for a specific category of item, you could restrict the number of items to it:

;WITH ExampleCte AS
(
    SELECT
        Id,
        Name,
        Description
FROM
    Items
WHERE
    Category = @Category_Id
)
SELECT
    ID, 
    Name, 
    Description
FROM
    ExampleCte
WHERE
    Has_Permission(@User_Id, Id)

This way records going into Has_Permission function will be limited to a specific category of items, so it won't be called as many times.

Another version of this query would be using tempdb table, but that's just an implementation and preference choice.

From my experience, if you need performance, the first option is always better, as it processes records in bulk, instead of doing them one after another. You should still analyze what is the best option in your specific case. That being said, be wary of scalar-valued functions, as they can make a big mess if you strive for the most optimal code!

SQL Server 2019 User-Defined Functions Inlining

For the sake of being thorough, I have to touch this subject.

What is UDF Inlining? Microsoft added it to the SQL Server 2019 to get rid of performance problems caused by scalar functions in queries. It's supposed to do our solution one: Inline the body of the function to main query, and make the whole thing perform better. However, there is a big problem.

It rarely works.

I've seen in it action, and it broke most of stored procedures in a freshly migrated project. It could destroy something in your project or not, but be warned: It can make a big mess.

Summary

Scalar-Valued Functions in WHERE statements are a big performance hit
You can easily inline them by hand or minimize the problem by restricting the amount of data processed by those functions
You can try to use UDF Inlining in SQL Server 2019, but you risk breaking every single stored procedure in your database.

Did you have the same experience with scalar functions in SQL Server? What are your ways of optimizing it? Please, share in the comments!

3 small tips to make your SQL Server experience easier

Jakub Rumpel — Thu, 22 Apr 2021 14:29:48 +0000

For most of the last two years, My job has been mostly about writing another and another SQL query, be it to check what's happening with some data, debug a weird error or develop a stored procedure as a part of a feature I'm working on. During that time I've written dozens of different procedures consisting of multiple queries, even to the point of committing small heresy in the form of two thousand lines monster full of XML deserialization and business validations.

Bad times.

But every such experience had left me with some new knowledge to use in future projects, things I could use to further optimize my SQL code or make some debugging easier, so I decided to share them in the form of this blog post

Easily commented out conditions

This one is very small and simple, but very useful when I need to write a query with multiple conditions. Let's take a look at the following example:


SELECT
    Id, 
    Name
FROM
    SomeTable
WHERE
    Field1 = "X"
    AND Field2 = "Y"

Now, here we already made our life easier by putting an AND keyword on the new line, right before second condition. It's a good practice when you're actively working on a query, because if you need to see what kind of result you'll achieve without the second condition, you can simply comment it out:

WHERE
    Field1 = "X"
    --AND Field2 = "Y"

See? Nice and easy, and in most SQL IDEs, like SSMS or DataGrip, you can comment out a single line with a simple shortcut.

But what if you want to see what would happen with second condition, but without first? If you leave AND keyword on its place, you'll just create an error, because there will be no condition preceding it:

--*SQL server won't let you do this, as there is no working condition before AND!*
WHERE
    --Field1 = "X" 
    AND Field2 = "Y"

Of course, you could move AND to the end of the first condition, but then it would trouble you if you need to comment out the second condition again. Or you could comment out AND like this: /AND/ and it would work, too. It's all fine and dandy, but what if there is other option?

WHERE 1=1
    AND Field1 = "X"
    AND Field2 = "Y"

Looks weird, but it could actually save you a lot of time. That way if you don't need any condition, you can simply comment it out, without breaking your whole query, which depending on size might be very difficult to find where did the error happened. Adding this simple 1=1 will not affect your qery performance in any significant way, but instead will make it much easier to work on query "right now".

Of course, it's not something I would leave in a production code, but for the sake of debugging, it can save you some precious seconds or even minutes, and most importantly, it will let you stay "in the flow", without being bothered by unexpected and irritating errors.

Instant insert into TempDB table from SELECT

Now this is something I've picked up just recently, but it instantly made my life much easier. Consider following code:

CREATE TABLE #Sample (Id INT, Name NVARCHAR(100), Description NVARCHAR(500))

INSERT INTO #Sample (Id, Name, Description)
SELECT
    Id, 
    Name,
    Description
FROM
    SampleTable
WHERE
    Condition = true

This example is very simple:

We create a temporal table (which is marked by # character at the beginning of the name)
We write its columns and their types
We repeat both table name and columns in INSERT statement
We fill it with data from SELECT statement

It still made us write quite a lot of words, and any mistake in data type or in choosing columns in an INSERT statement can lead to irritating errors, which could stop you for a long enough time that you'll lose your focus.

Instead, you could try this:

SELECT
    Id,
    Name,
    Description
INTO #Sample
FROM
    SampleTable
WHERE
    Condition = true

Yes: I just replaced both CREATE TABLE and INSERT INTO statements with single INTO between SELECT and FROM statements. What does it do? It creates a table with the same column names and types as ones we just retrieved from the database using our SELECT statement, without writing a lot of unnecessary code, and making it more difficult to make a mistake in the list of columns or risking that one of the columns will have a wrong type.

Of course, there is a "but": If you have to run this command multiple times, it won't just insert new data into our #Sample table, but instead it will throw an error saying that such a table already exists. We will deal with this in just a second:

Ensuring that unnecessary temporal table doesn't already exist

When we use temporal tables, sometimes we also have to delete them, especially when we are actively developing our query. Of course, it's less important when we use #table in stored procedure, as it will get dropped when the procedure is finished, and it's scoped to this procedure, just as our #table will be scoped to our DB session - but if it exists when it shouldn't, it's still a problem.

An obvious choice would be to simply DROP #table at the end of our query, but there is a risk: If for any reason #table doesn't exist when DROP is called, it will throw an error. Similarly, if for any reason the DROP statement won't be called (for example, because there was an error before it) next time we run our query we will also run into a problem.

So what's the solution?

IF OBJECT_ID('tempdb..#app') IS NOT NULL DROP TABLE #app

This single line of code will do two things:

Check if table #app already exists in tempdb
If it exists, it will drop it.

Put this line at the beginning of your SQL script, change the name to whatever you like, and you're good to go. If a table doesn't exist yet, nothing will happen, but if it exists before it should, it will be dropped.

This line makes an excellent work next to SELECT INTO statement, as it protects you against unnecessary errors while letting you use this statement easily.

For now, this will be all. If I remember (or find out) any other tips that can make my life a bit easier, this post will have a part 2.

Summary

You can make debugging SQL queries much simpler by adding "fake" 1=1 condition, and putting every "real" condition after AND or OR keywords.
Creating and filling tempdb tables can be very simple in SQL Server
There are a lot of possible errors while operating on tempdb tables, but you can avoid them if you remember that they are there

But what about You? Do You have any interesting tips or tricks you use in SQL Server that helps you get through the day? If you do, please share them in comments, I'd love to learn something new to use in my day-to-day SQL work.

Reading a Jira 6 tasklist in .NET

Jakub Rumpel — Wed, 21 Apr 2021 12:35:50 +0000

While automating some tasks during my software maintenance job, I thought it would be useful to be able to read the current task list straight from Jira. Our client is hosting instance of older version of Jira, about 6.X, so it still can show you a very simple filtered list, where every row in a table is a different task. It's not very complicated, but I could use it to further automate some processes, for example by automatically generate a possible solution to problems every morning, before I even wake up.

Or maybe to create an ASP.NET app which could generate a fix script given a single input, and after reading the task list, additionally it could give me ID of the task I just solved, and sample comment to write if it's very common case?

Either way, I thought it might be useful knowledge to someone looking to automate his job while being forced to use an older version of Jira.

What do you need?

Just your regular .NET SDK. Note that in my case I've been using .NET 5, but I think all of my code should work the same or with little differences in the earlier version of .NET, so it should be possible to easily reproduce in either .NET Core or .NET Framework 4.x

Steps

The only problem you might encounter while reading from Jira is the fact that you need to be logged in in order to read anything, so:

Log in to Jira using HttpClient
Read the task list in any way you want.

Logging in

To log in programmatically to Jira, you have to first check, how do you do it normally - through a browser. In my case, when I clicked "login", a request was sent to https://{LocalJiraUrl}/login.jsp with the following body:

{
    "os_username": "login",
    "os_password": "password",
    "os_destination": "",
    "user_role": "",
    "atl_token": "",
    "login": "Zaloguj się"
}

Let's take a closer look at this JSON:

os_username, os_password - Obviously, normally these would be my login and password to Jira system.
os_destination - I didn't investigate this deeper, but I suspect it would matter more if I tried to access some part of Jira, like a specific task, and was redirected to login page to authorize, to later by redirected to the page I tried to access in the first place.
user_role, atl_token - not sure what those two could be, and in what situations they would be used by Jira
login - It seems that this field passes a string written on login button, which in my case was "login" translated to Polish.

This one look simple enough to replicate - we just need to fill in username, password and probably login fields, and we'll be done. Right?

Sadly, no, there is one more thing to take care of: Cookies. For this to work, every request have to use cookies provided by Jira on the first GET request you make to their website. For the sake of knowledge, I will say that there are two: JSESSIONID and atlassian.xsrf.token. Good news is, we don't need their names, or any other information about them, when we write our code - we only have to remember that they are there, and we have to take care of them Let's look at the following code:

var cookies = new CookieContainer();
var handler = new HttpClientHandler();
handler.CookieContainer = cookies;

var client = new HttpClient(handler);
var result = client.GetAsync("https://{LocalJiraUrl}/login.jsp").Result;

Now let's analyze it step by step:

We created and initialized a new CookieContainer object
We created and initialized a new HttpClientHandler, which can be used as an optional argument in HttpClient constructor
We set CookieContainer in our HttpClientHandler to our freshly initialized CookieContainer
We created and initialized HttpClient using our HttpClientHandler.
We made a simple GET request to Jira. The fact that it's async is not important, as we immediately ask for .Result - new versions of .NET simply don't have synchronous Get method for HttpClient class.

Why did we do all this? So that when we make a GET request to Jira, we don't need to bother ourselves to look for specific cookies by their names in response that we got. This way any cookie from Jira response is automatically added to our CookieContainer, and we don't have to bother ourselves with them in any way.

Now we just prepare form data and post them to login page, and we're done:

var form = new Dictionary<string, string>
{
    {"os_username", login},
    {"os_password", password},
    {"os_destination", string.Empty},
    {"user_role", string.Empty},
    {"atl_token", string.Empty},
    {"login", "Zaloguj się"}
};

var response = client.PostAsync("https://{LocalJiraUrl}/login.jsp", new FormUrlEncodedContent(form)).Result;

And so, we are logged in. Time to get the tasks.

Read the task list

I have to admit: I'm lazy, so I won't make my life any harder than it needs to be. A version of Jira I'm working on allows me to simply export my filtered list of tasks in XML or RSS format. I just make a GET request using our logged in HttpClient to access the XML version of task list, and save it to the file:

var xmlResult = client
    .GetStringAsync(
        "https://{LocalJiraUrl}/sr/jira.issueviews:searchrequest-xml/20030/SearchRequest-20030.xml?tempMax=10000")
    .Result;

var path = "C:\\Users\\[username]\\Desktop\\test.xml";

File.WriteAllText(path, xmlResult);

All this does is hit a link XML result for filter 200300 (it's the ID of filter I used to get my daily tasks), get content as string using HttpClient.GetStringAsync(), and write it to file.

Of course, this is a simplified example - we could now Deserialize it to custom prepared class, and read it to our application to make processing of any kind, or put it in our local SQL Server Express database, or use any other method of storing this data in simplified format, so that we can use it at a later time.

Summary

In older version of Jira (which I believe are still commonly used) you can access task list programmatically
I did it only because I couldn't find any easily-accessible API in this Jira instance, so I had to get creative
If you want to automate your job, this might make your life a bit easier.
Cookies can't be avoided, but you can simplify handling them using HttpClientHandler.

Accessing default system locations in .NET Core

Jakub Rumpel — Tue, 20 Apr 2021 14:42:31 +0000

During my work as a software maintainer, I often find myself writing code not as a part of my regular work, but rather to automate tasks that by definition are done manually. As I wrote last time, I despise repetitive tasks, so I created few tools to automate things like checking status of data I've sent to being processed.

Why do I need to use locations like Desktop?

While coding one of those automation tools, I often found myself using locations like a desktop or my home directory to store some data needed by my console applications, which are run either by task scheduler or are added to my context menu and used on a specific directory.

One time I specifically decided to use Desktop, but I was worried that if I have to run it on a different computer (say, company will give developers new laptops) it would stop working and require recompiling. That's when I discovered a beautiful thing in .NET:

System.Environment.SpecialFolder

This is just a simple enum with fields like Desktop, Cookies, Fonts and others. It allows you to access any directory from this enum by simply choosing one of those fields in another Environment class method:

Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

which returns string with path to a given directory. Keep in mind, that SpecialFolder is just an Enum, so by itself it will only return a number, not a path!

Note that some paths from this Enum will work only on Windows, while others might return confusing results on Linux systems - so your experience might be different from mine.

Summary

If you need to quickly get a path to a place like Desktop or user home directory, you can use Environment.SpecialFolder to make it easier.
You can check the full list of SpecialFolder fields on its Microsoft page.
If you're deploying it on different OS than Windows, always check what kind of results you can expect using SpecialFolder.
You can find some more information about using SpecialFolder on Linux on this blogpost. Note: It's for .NET Core 2.1

Simplify and automate

Jakub Rumpel — Mon, 19 Apr 2021 13:52:55 +0000

It's only 2PM when I write this post, but the title already saved me a ton of time - in fact, enough to easily take a break to post this.

After reading this post, I want you all to have a simple takeaway: If you can simplify and automate some process, you should probably do it. In fact, there is a saying within sysadmins of Reddit - "If you did it more than once, you should automate it". It is very applicable in software maintenance, where we already have to write scripts to do our job - so why not write them a bit smarter, so they can do our job for us without taking any of our time?

What happened?

An error occurred in integration between our client and systems in the other company (let's call it company B). It wasn't a critical error - but some information wasn't received on their end, which resulted in further problems that could lead to potential money loss - so the worst situation possible in corporations.

Now, this kind of situation happens now and then, but usually on a much smaller scale. Once a day, maybe, a single row of data fails to be delivered properly, and has to be re-exported. I didn't automate the process of re-exporting yet, but here comes the first lesson.

Simplify.

A lot of my work is done on SQL Server databases, and a lot of it is executing identical scripts with different input data. The most important thing I learned is to always save these scripts somewhere on my computer in the purest form possible, so that if I ever need it again, I can just copy and paste some numbers as an input and send it to execution - without losing an hour of time to write the same script I wrote a week or three months ago.

My simplification of this problem is to keep the template for re-exporting data to company B. I have two scripts - one to check what data need to be exported, and the other for exporting. This way, all I need to do is run the first with a single number as an input, copy and paste data to the other script, and then run it. It's a few hundreds lines of SQL code every time, but it takes me approximately one minute or less to complete the task, which otherwise would take up to an hour. I plan on making them one script, but lack of time is preventing me so far from fulfilling this plan.

Tip: If you work with other people in the same field, and you use the same scripts, you can easily symlink a directory from a shared location to a templates' directory of SQL Server Management Studio. Following snipped is for Windows, but it can easily be reproduced on other OS'es.

mklink /d //networkShare/DirectoryName /SSMS/TemplateDirectory

This way you can easily add, edit or delete scripts, and your whole team always has the newest version.

Automate.

If you already have some fields where you always use the same scripts with different inputs, more often than not you can write just a bit of code, and the script can be fully automated. In my case, automation isn't full and complete yet, but it's already saving me a lot of time, which otherwise would have to be spent on boring and repetitive tasks.

My automation for this problem is simple: Once I re-exported the data to company B systems, I still have to occasionally check if everything has been properly processed. This is the most boring part - every day I had to run the same scripts about ten times to check each row of data, and if processing of any is finished, pass the info to the client that we're good.

All I've done was to write a piece of code to read rows of data from a TXT file and run the query for each of them. If processing of any file is complete, code emails me with the number of tasks in Jira and ID of data which was processed (as sometimes there is more than one ID in Jira task). After that, row is deleted from TXT file, and it's work there is done.

All that took me about one full day to write, which I've done over the weekend, and then another day to set up and test on my work computer. Simple automation, but it's nice to wake up and see that your work is done for you.

How it helped?

Today an error occurred on some 40+ rows of data. Thanks to my simplification, it didn't take much time to re-export them to company B, and it won't take any of my time in coming days to make sure that everything work's swimmingly on the other end. Win-win, isn't it?

Summary

If you do it more than once, automate it.
Save every script you run on your database - there is a big chance you will need it again.
Use applications and functionalities that can make your life easier, like Template Library in SSMS.
If you find yourself often running the same script with different input, there is a big chance you can automate it.

PS. This post was inspired by Andrzej Krzywda's and Arkademy's Blogconf and #5days5blogposts challenge. I recommend checking him out, and checking what Arkademy offers in terms of courses and sharing knowledge about programming - not only about code per se, but also about just making what you create better in every way.