[ .NET, C#, SQLite, iTextSharp ]

A few years ago I worked as a researcher in linguistics, analyzing and studying text documents was a crucial part of the job. However, the manual process of counting and studying the frequency of words in electronic documents can be a tedious and time-consuming task. To solve this problem, and with the suggestion of my supervisor, I developed this app to streamline the process. It is designed to support batch processing of various types of electronic text documents, including pdf, txt, doc, docx, odt, xlsx, htm, html, and rtf formats. It also supports a single data warehouse, making it easy to store, search and retrieve information.

One of the essential functions of the app is counting the number of characters and words in each document. This feature saves users time and energy, as it automatically generates these statistics and presents them in an easy-to-read format. Another critical function of the app is the study of the frequency and density of words in each document. This feature allows users to gain insights into the use of specific words and phrases in each document and the overall language patterns used by the author. The app also allows users to search for words according to given conditions, making it easier to study specific topics or themes in a document.

The app was developed using C#, a programming language that is widely used in the development of Windows applications. It also uses the ITextSharp library, which is an open-source library used for generating and manipulating PDF documents. To store the data generated by the app, I decided to use an SQLite database. SQLite is a lightweight, open-source database that is widely used in mobile and desktop applications. It is a self-contained, serverless database that requires minimal setup and administration, making it an ideal choice for small to medium-sized applications.

Overall, the app I developed is an excellent tool for researchers, students, and anyone who works with electronic text documents. It streamlines the process of studying, ranking and analyzing the frequency of words, saving users time and energy. It is written using modern programming languages and adheres to best coding practices, ensuring it is easy to maintain and extend.

Download from GitHub: DoshStat

[ ASP .NET Core, SOAP ]

SOAP (Simple Object Access Protocol) is a messaging protocol used in web services to exchange data between applications. In this article, we will explore the use of a connected SOAP service in a software development project. We will examine a sample app that uses a SOAP service to register a new customer and then sign in a user.

The code is written in C# and consists of two controllers: RegisterController and SignInController. These controllers. Each controller has corresponding views to register and sign in.

Before consuming the ICUTechService SOAP service it first must be represented by classes in our code, VS has a convenient way to scaffold those for us. Here are the steps:

1. Right-click on the project in Solution Explorer, and select “Add” -> “Connected Service”.
2. In the “Add Connected Service” dialog box, select “Microsoft WCF Web Service Reference Provider” and click on “Configure”.
3. In the “Configure WCF Web Service Reference” dialog box, enter the URL of the ICUTechService WSDL file in the “Service URL” field and click on “Go”. This will load the WSDL and generate a preview of the service reference.
4. In the “Configure WCF Web Service Reference” dialog box, you can specify the namespace for the service reference and the name of the service reference. You can also choose to enable or disable “Reuse types in referenced assemblies”.
5. Click on “OK” to generate the service reference.

After that the wizard will create for us the ICUTechServiceReference class, which in turn has ICUTechClient() method, by calling that method we aquire access to the public methods of the service, the rest is easy:

  public class RegisterController : Controller
    {
        [HttpPost]
        public async Task<IActionResult> Index(string email, string password, string firstName, string lastName, string mobile)
        {
            ViewBag.IsDeveloperMode = true;
         
            var client = new ICUTechClient();
            var rawResponse = await client.RegisterNewCustomerAsync(email, password, firstName, lastName, mobile, 0, 0, "");
            ViewBag.ResponseData = JsonConvert.DeserializeObject(rawResponse.@return);

            return View();
        }
        public IActionResult Index()
        {
            return View();
        }
    }

It has two methods, Index and Index(HttpPost). The Index method returns a view for displaying the registration form to the user. The Index(HttpPost) method is called when the user submits the registration form. The method creates an instance of the ICUTechClient class and calls the RegisterNewCustomerAsync method to register a new customer with the ICUTechServiceReference service. The method then deserializes the raw response from the service using the Newtonsoft.Json library and sets the ViewBag.ResponseData property with the deserialized data.

public class SignInController : Controller
{
    [HttpPost]
    public async Task<IActionResult> Index(string username, string password)
    {
        ViewBag.IsDeveloperMode = false;

        var client = new ICUTechServiceReference.ICUTechClient();
        var rawResponse = await client.LoginAsync(username, password, "");
        ViewBag.ResponseData = JsonConvert.DeserializeObject(rawResponse.@return);
        
        return View();
    }
    public IActionResult Index()
    {
        return View();
    }
}

The SignInController class is similar to the RegisterController class, but instead of registering a new customer, it signs in an existing user. The class has two methods, Index and Index(HttpPost). The Index method returns a view for displaying the sign-in form to the user. The Index(HttpPost) method is called when the user submits the sign-in form. The method creates an instance of the ICUTechClient class and calls the LoginAsync method to sign in the user with the ICUTechServiceReference service. The method then deserializes the raw response from the service using the Newtonsoft.Json library and sets the ViewBag.ResponseData property with the deserialized data.

Considering the simplicity of our business logic, this is basically it, add an HTML wrapper and you are good to go! Using SOAP services can be a powerful tool in software development, allowing you to easily exchange data between applications. With a little bit of knowledge and some basic programming skills, you can leverage the power of SOAP to build robust and scalable applications that meet the needs of your users.

Check out the complete code in my GitHub repo:
https://github.com/movsar/mk-task

[ PHP, JS, AngularJS, MySQL, Yandex API, Wialon SDK ]

As a software developer, one of my past projects was building a geo-information system in 2016. Using AngularJS, MySQL, PHP, HTML & CSS, and Bootstrap, I developed a robust application that offers a range of features to help companies track and manage their assets efficiently.

One of the most interesting features of the application is its advanced security. To protect the JavaScript code, PHP wrappers were used, ensuring that the code is tamper-proof and cannot be manipulated by malicious users. The application also has an authorization flow that requires users to authenticate before they can access the system, thus preventing unauthorized access to sensitive data. The access management system in the application is another noteworthy feature. With this system, administrators can assign roles to users and set object-level permissions. This ensures that users only have access to the information they are authorized to view or modify. Additionally, the system provides an audit trail of all user activities, making it easy to track changes and detect any unauthorized access attempts.

The core functionality of the application is the ability to build different types of objects with full CRUD support, which can be saved using a geo-coordinate system. This feature makes it easy for users to add and manage objects in a geo-environment. Objects can be plotted on a map using the system’s intuitive interface, which makes it easy to locate objects visually. This feature is useful for companies that need to manage large amounts of objects, such as pipelines, power grids, or other types of infrastructure.

Users can filter objects by type, organization, and other criteria, and then generate custom CSV reports based on their selected filters. This feature is useful for extracting insights from the data and making informed decisions. The geo-information system is a reliable and efficient solution for companies looking to track and manage their assets in a geo-environment. Its advanced security features, access management system, object management, and custom report generation make it a valuable tool for businesses in a range of industries.

[ Java, Android SDK, PHP, MySQL, Realm, JS, jQuery ]

The android app is a unique platform that brings together the Chechen community and serves as a hub for Chechen language. Available for download on the Google Play Store and online at https://nohchiyn-mott.com, the app is designed to cater to the needs of the Chechen diaspora worldwide, providing a space to connect and engage with others who share the same heritage.

One of the key features of the app is its interactivity, which enables users to add, edit, and rate the dictionary’s entries. This allows for a dynamic and up-to-date dictionary, as new words and definitions can be added as they are created. Moreover, users can rate each entry, which helps to identify the most accurate and widely accepted definitions. The app also provides a change history feature, which allows users to see how the definitions have evolved over time.

Written in Java, the app has rich functionality to filter entries, making it easy for users to find the words they need. The app uses an offline-first approach with a robust Realm database, which means that the app can be used even without an internet connection. However, the app synchronizes with a remote MySQL database, which ensures that the app stays up-to-date with the latest changes and additions. The app consists of an Android app written in Java and PHP files that serve as the backend for remote database operations.

One of the most significant aspects of the app is that it is community-driven. Users can register and participate in building and maintaining the dictionary, ensuring that the app remains a useful and relevant resource for the Chechen language community. The app’s design and functionality reflect the importance of community participation in language preservation efforts.

In conclusion, the Chechen Language Dictionary app is a fantastic example of how technology can be used to preserve and promote endangered languages. The app’s interactive features, robust database, and community-driven approach make it a valuable resource for the Chechen language community. As technology continues to advance, it is exciting to see how apps like this can help to protect and promote languages that are at risk of disappearing.

Download for Android: Chechen Language Dictionary
Online version: https://nohchiyn-mott.com

[ .NET, C#, WinForms, RegEx ]

As I continue posting my past projects, here is one from my university years. It is a C# WinForms dictionary application that is designed to translate words and phrases from Russian to Chechen language. The application is based on the .NET Framework and uses the WinForms technology for creating a graphical user interface (GUI).

Overview of the Application

The C# WinForms dictionary application is called “Noxçiyn Doşam”, which translates to “Chechen Dictionary” in English. The application is designed to be easy to use and intuitive, with a simple and clean user interface that allows users to search for words and phrases in the Russian language and get their translations in the Chechen language.

The main window of the application consists of a search bar, a list box that displays the search results, and a label that shows the description of the selected word or phrase. Users can type in a word or phrase in the search bar and press Enter to search for it. The search results are displayed in the list box, with the matching words or phrases highlighted in yellow. Users can click on a word or phrase in the list box to select it and view its description in the label below. The application also includes a menu bar that provides additional functionality, such as the ability to exit the application, view the application version and copyright information, and change the font size and color of the text in the label and list box.

Code Structure and Design Patterns

The C# WinForms dictionary application is written in C# and uses the Visual Studio development environment for creating the GUI and writing the code. The code is organized into classes and methods that implement the various features and functionality of the application.

The main class of the application is called frmMain, which is a subclass of the Form class provided by WinForms. This class contains all the code that defines the behavior and appearance of the main window of the application. It also contains event handlers for responding to user actions, such as clicking on a menu item or selecting a word or phrase in the list box. The frmMain class uses several other classes and methods to implement the various features of the application, such as loading the dictionary data from a file, searching for words and phrases in the dictionary, and displaying the search results in the list box.

One of the key design patterns used in the application is the Model-View-Controller (MVC) pattern, which separates the application logic (the Model) from the user interface (the View) and the user input (the Controller). The Model consists of the dictionary data and the methods that operate on it, while the View consists of the GUI elements that display the data to the user. The Controller consists of the event handlers that respond to user input and update the Model and the View accordingly.

Another design pattern used in the application is the Singleton pattern, which ensures that there is only one instance of a particular class throughout the lifetime of the application. This pattern is used to implement the frmMain class as a Singleton, which ensures that there is only one main window of the application and prevents multiple instances from being created accidentally.

Download: Nohchiyn Dosham

[ Salesforce, JS, Jest, Apex, HTML, CSS, Unit Tests ]

This is a project that was assigned to me when I tried to apply to a job. It’s a currency converter that can be used in both Salesforce Cloud and Experience Cloud web apps. It uses a public API to retrieve the rate, consists of LWC components, and an Apex backend. With this tool, users can easily convert currencies within Salesforce, saving them time and hassle.

The currency converter is made of several LWC components that are built with custom CSS styles. This not only gives the tool a professional look, but it also makes it easy for users to navigate and understand. The components are also designed to be responsive, meaning that they look great on any device. Behind the scenes, the currency converter is powered by an Apex backend and throughout the project I tried to keep everything consistent with SOLID principles. This ensures that all of the data is secure, testable and that the tool can handle large amounts of traffic. The backend retrieves currency rates and information from a public API, meaning that the data is always up-to-date and accurate. Here’s how the rates are calculated:

import Id from '@salesforce/user/Id';

const Utils = {
    gbpRates: [],
    calculateRates: function (baseCurrency) {
        if (!baseCurrency){
            console.error('calculateRates: base currency is empty');
            return;
        }
        let ratesForNewBaseCurrency = [];
        for (let i = 0; i < this.gbpRates.length; i++) {
            let newBaseRateInGbp = this.gbpRates.find(rate => rate.code === baseCurrency);
            let newRate = {};
            newRate.code = this.gbpRates[i].code;
            newRate.value = this.gbpRates[i].value / newBaseRateInGbp.value;
            newRate.order = LocalSettings.getCurrencyOrder(newRate.code);
            ratesForNewBaseCurrency.push(newRate);
        }

        // Sort by usage frequency
        ratesForNewBaseCurrency = ratesForNewBaseCurrency.sort((a, b) => (a.order > b.order) ? -1 : ((a.order < b.order) ? 1 : 0));
        
        return ratesForNewBaseCurrency;
    },
    ...
}
...

One of the key design principles that I followed when creating the currency converter is SOLID. This stands for Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles help ensure that the code is easy to understand, maintain, and expand over time.

To ensure that everything was working as intended, I also wrote unit tests using Jest. These tests cover all of the key functionality of the currency converter, from retrieving currency rates to converting currencies. By writing these tests, I was able to catch and fix any issues early on, ensuring that the tool was ready for use.

This is how one of the test files look like:

import { createElement } from 'lwc';
import CurrencyConverter from 'c/CurrencyConverter';
const mockData = require('./mockData.json');
const flushPromises = () => new Promise(setImmediate);
import fetchMock from "jest-fetch-mock";


describe('c-currency-converter', () => {
    afterEach(() => {
        // The jsdom instance is shared across test cases in a single file so reset the DOM
        while (document.body.firstChild) {
            document.body.removeChild(document.body.firstChild);
        }
    });

    it('retrieve data test', async () => {
        const element = createElement('c-currency-converter', {
            is: CurrencyConverter
        });
        element.ratesPerPage = 2;

        fetchMock.enableMocks();
        fetch.mockResponseOnce(JSON.stringify({ rates: { CAD: 1.42 } }));

        document.body.appendChild(element);
        await flushPromises();

        const subheaderElement = element.shadowRoot.querySelector('[data-id=subheader]');
        const subheader = subheaderElement.textContent.split('on ')[1].replace(/\:\d+$/, '');
        const dateTimeNow = (new Date()).toLocaleString().replace(/\:\d+$/, '');

        // Check last update date time, as retrieveData is mocked, these should be the same
        expect(subheader).toEqual(dateTimeNow);
    });

    it('handlers test', async () => {
        const element = createElement('c-currency-converter', {
            is: CurrencyConverter
        });
        element.ratesPerPage = 2;

        fetchMock.enableMocks();
        fetch.mockResponseOnce(JSON.stringify({ rates: { CAD: 1.42, GBP: 1, USD: 2 } }));

        document.body.appendChild(element);
        await flushPromises();

        const currencyConverterCalc = element.shadowRoot.querySelector('c-currency-converter-calc');
        currencyConverterCalc.dispatchEvent(new CustomEvent("basechange", {detail: 'GBP'}));
        await flushPromises();

        currencyConverterCalc.dispatchEvent(new CustomEvent("quotechange", {detail: 'GBP'}));
        await flushPromises();

        const currencyConverterList = element.shadowRoot.querySelector('c-currency-converter-list');
        currencyConverterList.dispatchEvent(new CustomEvent("nextpage"));
        await flushPromises();

        currencyConverterList.dispatchEvent(new CustomEvent("previouspage"));
        await flushPromises();

    });
});

The first test case checks the “retrieve data” functionality, where the component fetches the latest currency exchange rates from an API and displays them on the UI. This test case mocks the API response and checks if the component is displaying the last update date and time correctly.

The second test case checks the event handlers of the component, where the user interacts with the UI to change the base and quote currencies and to navigate between pages of the currency rate list. This test case dispatches CustomEvents to simulate user interactions and checks if the component responds to these events correctly.

The test suite also contains an afterEach hook that resets the DOM after each test case.

Check out the complete code:
GitHub: https://github.com/movsar/kassignment

[ .NET, WinForms ]

Text conversion is a common task that many people encounter in their daily lives. Sometimes, we need to convert text from one format to another, such as from Cyrillic to Latin script. This can be particularly important in certain contexts, such as when dealing with languages that use different writing systems. In this blog post, I will introduce an application that performs two-directional text conversion between Cyrillic-based Chechen and Latin-based Chechen. This application has a rich user interface that makes it easy and intuitive to use.

The first thing you’ll notice when you open the application is the clean and modern design of the user interface. The layout is straightforward and easy to understand, with a large input area for entering text and a button to initiate the conversion process. The application supports both Cyrillic and Latin-based input, and the user can select the desired input mode from a drop-down menu. Additionally, there is an option to copy the converted text to the clipboard or save it as a file.

The conversion process itself is fast and accurate. The application uses a custom algorithm to perform the conversion, which ensures that the resulting text is accurate and grammatically correct. The algorithm also supports advanced features such as case conversion, diacritic conversion, and automatic spelling correction.

Another notable feature of this application is its support for two-directional text conversion. This means that users can convert text from Cyrillic to Latin-based script or from Latin to Cyrillic-based script, depending on their needs. This feature is particularly useful for users who need to communicate with others who use a different writing system.

In conclusion, this application is a powerful and intuitive tool for performing two-directional text conversion between Cyrillic-based Chechen and Latin-based Chechen. Its rich user interface makes it easy to use, while its advanced conversion algorithm ensures fast and accurate results. Whether you’re communicating with friends and family or working on a professional project, this application is an essential tool for anyone who needs to convert text between different writing systems.

GitHub: https://github.com/movsar/cyrtolat

[ JS, PHP, Scraping ]

Web scraping is a technique used for extracting large amounts of data from websites, which can then be used for various purposes such as market research, data analysis, or data-driven decision-making. In this article, we will walk through the front-end code for a PHP web scraper that was built to scrape data from autotrader.co.uk, a European car dealer website.

Before diving into the code, it is important to note that this code is presented only for a presentation, and it is not meant to be used ‘as is’. Additionally, the scraper supports proxy servers and is basically bulletproof because of the techniques used in code to detect any failures and fix them during the execution. Also, it supports multiple instances, and the UI has controls to start scraping at different locations which comes handy quite often.

The front-end code consists of an HTML file, ‘index.html,’ and a JavaScript file, ‘app.js.’ The HTML file contains the basic structure of the user interface, which includes input fields for the make index, model index, and page index. These input fields allow the user to specify the range of data they want to scrape. Additionally, the HTML file contains a ‘Start’ button, which triggers the scraping process. The JavaScript file, on the other hand, contains the code that actually scrapes the data.

To begin, the JavaScript file starts by setting some constants for delay times between scraping requests. These constants, DELAY_CARS, DELAY_IDS, and DELAY_TRY_AGAIN, are used to ensure that the scraping process runs smoothly without overloading the website’s servers.

Next, the script defines a sleep function that is used to pause the execution of the script for a specified amount of time. This function is useful for ensuring that the scraper does not send too many requests to the website at once, which could lead to server overload or IP blocking. The rnd function generates a random number between two specified values, which is used to randomize the delay times between scraping requests. This randomization helps to further ensure that the website’s servers are not overloaded and that the scraper is not detected and blocked. The request function is used to send HTTP requests to the website’s servers. This function takes a payload object as an argument, which contains the URL to be scraped and any other necessary parameters. The function returns a Promise object, which resolves to the server’s response.

Here’s the main backend code in PHP:

function scrapeCarInfo($id, $proxy)
{
    $GLOBALS['db']->where("carId", $id);
    $res = $GLOBALS['db']->getOne("autoradar_cars");

    if ($res !== null) {
        return (json_encode(["id" => $id,  "index" => $res['id'], "notes" => 'already there']));
    }

    if (strlen($id) > 20) {
        // new car

        $response = json_decode(request(array('url' => 'https://www.autotrader.co.uk/json/new-cars/derivative/get?id=f0d8e2aea02747a998f94f28c981a0eb', 'proxy' => $proxy)));
        if (property_exists($response, 'ERR_CODE')) return json_encode($response);
        $ci = ($response);

        usleep(250000);

        $response = json_decode(request(array('url' => 'https://www.autotrader.co.uk/json/dealers/search/by-derivative?derivativeId=f0d8e2aea02747a998f94f28c981a0eb&postcode=e161xl', 'proxy' => $proxy)));
        if (!is_array($response)) return $response;
        $di = ($response);

        $title = $ci->make . " " . $ci->name;
        $phone = $di[0]->review->dealer->phoneNo1;
        $price = $ci->price;
        $href = 'https://www.autotrader.co.uk' . $ci->uri;
    } else {
        //  used car
        $response = json_decode(request(array('url' => ('https://www.autotrader.co.uk/json/fpa/initial/' . $id), 'proxy' => $proxy)));
        if (property_exists($response, 'ERR_CODE')) return json_encode($response);

        $carInfo = ($response);

        $title = $carInfo->advert->title;
        $phone =  $carInfo->seller->primaryContactNumber;
        $price = $carInfo->advert->price;
        $href = 'https://www.autotrader.co.uk/classified/advert/' . $id;
    }

    // Save data
    $data = array(
        'carId' => $id,
        'title' => $title,
        'href' => $href,
        'phone' => $phone,
        'price' => $price
    );


    $insertedId = $GLOBALS['db']->insert('autoradar_cars', $data);
    $response = array("id" => $id,  "index" => $insertedId);

    return json_encode($response);
}

The updateUI function is used to update the user interface with information about the scraping progress. This function extracts information from the scraping process, such as the make index, model index, and page index, and displays it in the appropriate input fields. Finally, the script defines an array of proxy servers that are used to send the scraping requests. This array contains a list of IP addresses and port numbers, which are used to randomize the proxy server used for each request.

In conclusion, the PHP web scraper presented here is a simple yet effective tool for scraping data from autotrader.co.uk. While the code presented here is not meant to be used ‘as is’, it provides a solid foundation for building more complex scraping tools. With the right modifications and adjustments, this scraper can be used to extract a wide range of data from other websites as well.

GitHub: https://github.com/movsar/xscraper

[ .NET, PHP, WinForms ]

As the world becomes more interconnected and reliant on technology, the need for remote administration tools has increased. A remote administration app allows system administrators to manage multiple computers simultaneously without having to physically access them. In this article, we’ll discuss the architecture of a remote administration app that supports managing multiple computers through command lists. It’s one of my past projects that I built around 2011.

The app is built using VB.NET for the client-side and PHP for the web part. The client-side app runs on the computers that the administrator wants to manage, while the web part runs on the administrator’s computer. The client-side app runs passively in the background and listens for commands from the web part. The app uses a command list to manage the computers. The command list is a plain text file that contains a list of commands that the client-side app should execute. The commands can be used to update files, download files, create or delete files, and rename files. The client-side app reads the command list and executes the commands one by one. The client-side app also sends back the output of the executed commands to the web part. The web part then displays the output to the administrator. This allows the administrator to see the results of the commands and make decisions based on the output. The app is designed to be flexible and customizable. The administrator can create custom command lists for specific tasks. For example, a command list can be created to update software on multiple computers at once. The administrator can also add new commands to the app to extend its functionality.

One of the key features of the app is its ability to manage multiple computers simultaneously. The administrator can create a command list that targets multiple computers, and the app will execute the commands on all of them. This saves the administrator time and effort by allowing them to manage multiple computers at once. The app also supports error handling and logging. If a command fails to execute on a computer, the app will log the error and continue with the rest of the command list. This allows the administrator to identify and fix errors quickly.

In conclusion, a remote administration app is a powerful tool for system administrators who need to manage multiple computers simultaneously. The app we’ve discussed in this article is designed to be flexible, customizable, and easy to use. By using a command list, the app allows administrators to execute complex tasks on multiple computers with ease. With its error handling and logging capabilities, the app is also designed to be reliable and robust.