Tworzenie serwisu zarządzającego

1. Tworzymy plik konfiguracyjny, który pozwoli na połączanie z bazą MySQL. Najlepiej umieścić poza katalogiem ze stroną.

<?php
$host = "localhost";
$db_user = "root";
$db_pwd = "YOURPASS";
$db_name = "zseu";
$connection = mysql_connect($host, $db_user, $db_pwd);
if (!$connection) die('Could not connect: ' . mysql_error());
$db_selected = mysql_select_db($db_name, $connection);
if (!$db_selected) die ('Nie można ustawić '.$db_name.' : ' . mysql_error());
?>

Zapisujemy go na serwerze www ( /var/www ), jako config.inc

2. Strona główna wygląda następująco:

<?php
(@include_once('../config.inc')) or die ("Brak pliku konfiguracyjnego");
?>
<!doctype html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Naprawa sprzętu</title>
</head>
<body>
<table border="1">
    <tr>
<td>Lp.</td>
<td>Nazwa sprzętu</td>
<td>KS</td>
<td>Data zgłoszenia</td>
<td>Data naprawy</td>
<td>Data zwrotu</td>
<td>Serwis</td>
    </tr>
<?php
$q = mysql_query("SELECT * FROM naprawa");
$lp = 0;
while($row =  mysql_fetch_assoc($q))
{
    $lp++;
    echo "<tr>
<td>$lp</td>
<td>$row[nazwa_sprzetu]</td>
<td>$row[ks]</td>
<td>$row[data_zgloszenia]</td>
<td>$row[data_naprawy]</td>
            <td>$row[data_zwrotu]</td>
<td>$row[serwis]</td>
</tr>";
}
?>
</table>
<a href="/admin" alt="Panel administracyjny">Panel administracyjny</a>
</body>
</html>

Tworzenie bazy pod serwis zarządzający

1. Tworzymy bazę

mysql -u root -p -e 'create database zseu'

2. Logujemy się do MySQL

mysql -u root -p

3. Tworzymy wcześniej zaplanowaną strukturę bazy danych

use zseu;
CREATE TABLE naprawa (
id INT NOT NULL AUTO_INCREMENT,
nazwa_sprzetu VARCHAR(100) NOT NULL,
ks VARCHAR(40) NOT NULL,
data_zgloszenia DATETIME,
data_naprawy DATETIME,
data_zwrotu DATETIME,
serwis VARCHAR (20) NOT NULL,
PRIMARY KEY (id));

4. Sprawdzamy rezultat

DESC naprawa;

5. Tworzymy kolejną tabelę z nazwą serwis

CREATE TABLE serwis (
id INT NOT NULL AUTO_INCREMENT,
nazwa_serwisu VARCHAR(100) NOT NULL,
telefon VARCHAR(255) NOT NULL,
PRIMARY KEY (id));

DESC serwis; 

6. Tworzymy ostatnia tabelę z danymi logowania administratorów do panelu.

CREATE TABLE users (
id INT NOT NULL AUTO_INCREMENT,
login VARCHAR(100) NOT NULL,
password CHAR(32) NOT NULL,
isAdmin tinyint(1) DEFAULT 0 NOT NULL,
PRIMARY KEY (id));

DESC users; 

7. Tworzymy pierwszego administratora strony:

 insert into users (login, password, isAdmin) VALUES ('admin', MD5('YOURPASS'), 1); 

3. Tworzenie serwisu zarządzającego

Instalacja PHP, MySQL i Apache

1. Instalacja, uruchomienie oraz dodanie do autostartu serwera Apache

yum install httpd
service httpd start
chkconfig httpd on

2. Odblokowujemy port 80 w firewall'u

iptables -I INPUT 5 -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT
service iptables save
service iptables restart

3. Sprawdzamy czy serwer funkcjonuje poprawnie wpisując w przeglądarkę IP serwera

ifconfig eth0 | grep inet | awk '{ print $2 }'

4. Instalacja MySQL

yum install mysql-server
service mysqld start
chkconfig mysqld on

4a. Zakładamy hasło dla użytkownika root w MySQL

mysqladmin -u root password YOURPASS

5. Instalacja PHP

yum install php php-mysql

6. Załączamy raportowanie błędów w apache w pliku php.ini, znajdujemy jego lokalizację i edytujemy:

php -i | grep "php.ini"

display_errors = On

7. Instalacja potrzebnych modułów

yum search php-

8. Pierwszy plik php na serwerze

/var/www/html/index.php

############## Zawartość pliku index.php ##############
<?php
phpinfo();
?>
##################################################

service httpd restart

2. Tworzenie bazy pod serwis zarządzający

Wake On Lan (WOL) - Lokalne włączanie komputerów

Wake On Lan to metoda włączania komputerów poprzez sieć lokalną (LAN).
Polega ona na wysłaniu Magic Packet do karty sieciowej, która przesyła informację do płyty głównej o potrzebie załączenia się. Jeżeli chodzi o laptopy to ta funkcja również jest dostępna tylko musi mieć zewnętrzne źródło zasilania, na baterii funkcja WOL nie działa.

Chcąc załączyć komputer, musimy znać jego MAC adres karty sieciowej.

Z programistycznego punktu widzenia, potrzebujemy napisać program, który będzie wyśle najpierw 0xFFFFFFFFFFFF, a następnie 16x Mac adres - na podany mac adres.

Dla design'u aplikacji wystarczy TextBox i Button.

Tworzymy event dla przycisku:

private void button1_Click_1(object sender, EventArgs e)
{
    try
    {
        SendMagicPacket(textBox1.Text);
        MessageBox.Show("Packet Sent to " + textBox1.Text);
    }
    catch (Exception ex) { MessageBox.Show("Error:\n\n" + ex.Message, "Error"); }
}

Przycisk jest już gotowy, pozostała tylko funkcjonalność:

public static void SendMagicPacket(string macAddress)
{
    if (!Test(macAddress))
        throw new ArgumentException("Niepoprawny MAC adres", "macAddress", null);

    byte[] mac = ConvToByte(macAddress);
    WakePC(mac);
}

Musimy też sprawdzić czy wprowadzony mac adres jest poprawny, jak widać powyżej jest funkcja Test().

public static bool Test(string macAddress)
{
    var valid_chars = "0123456789ABCDEFabcdef";
    if (string.IsNullOrEmpty(macAddress)) return false;
    if (macAddress.Length != 12) return false;
    foreach (var c in macAddress)
    {
        if (valid_chars.IndexOf(c) < 0) { return false; }
    }
    return true;
}

Gdy nasz Mac adres jest poprawny, to rozkładamy go na bajty funkcja ConvToByte():

public static byte[] ConvToByte(string macAddress)
{
    byte[] mac = new byte[6];
    if (!Test(macAddress))
        throw new ArgumentException("Niepoprawny MAC adres", "macAddress", null);

    for (var i = 0; i < 6; i++)
    {
        var t = macAddress.Substring((i * 2), 2);
        mac[i] = Convert.ToByte(t, 16);
    }
    return mac;
}

Ostatnim krokiem będzie wysłanie, przed chwilą otrzymanych bajtów, do karty sieciowej, ale przed tym jeszcze sprawdzenie czy nasze bajty zostały poprawnie przekonwertowane.

public static bool TestByteArray(byte[] macAddress)
{
    if (macAddress == null) return false;
    if (macAddress.Length != 6) return false;
    return true;
}

public static void WakePC(byte[] macAddress)
{
    if (!TestByteArray(macAddress))
        throw new ArgumentException("Niepoprawny MAC adres", "macAddress", null);

    using (UdpClient client = new UdpClient())
    {
        client.Connect(IPAddress.Broadcast, 40000);
        byte[] packet = new byte[17 * 6];
        for (int i = 0; i < 6; i++) { packet[i] = 0xFF; }
        for (int i = 1; i <= 16; i++)
        {
            for (int j = 0; j < 6; j++)
            {
                packet[i * 6 + j] = macAddress[j];
            }
        }
        client.Send(packet, packet.Length);
    }
}

Poniżej obrazek jak aplikacja wygląda i jak powinno się wpisywać Mac adres :)

Enjoy !

WPF Canvas - Hexstring to image

Jak odczytać obrazek zapisany na przykład w MSSQL?
Można na dwa sposoby.

Pierwszy sposób polega na skopiowaniu z bazy hex stringu i wstawienie go do DrawImage(), który później za pomocą HexStringToBytes() jest konwertowany do byte[].

public void DrawImage(string hexvalue)
{
    canvas1.Children.Clear();
    byte[] byBitmap = HexStringToBytes(hexvalue);

Drugim sposobem jest połączenie się do bazy MSSQL z poziomu programu i wykonanie odpowiednich zapytań, aby odnieść się do komórki z naszym obrazkiem, tzw. Binary Data.
Tutaj już nie korzystamy z HexStringToBytes(), tylko po odpowiednim zapytaniu odwołujemy się do kolumny "pic", gdzie jest zapisany obrazek.

public void DrawImage()
{
    //Połączenie z bazą + zapytanie
    canvas1.Children.Clear();
    byte[] byBitmap = (byte[])result["pic"];

Poniższy przykład przedstawia narysowanie obrazku w canvas z hexstringu.

public void DrawImage(string hexvalue)
{
    canvas1.Children.Clear();
    byte[] byBitmap = HexStringToBytes(hexvalue);
    var Bitmap = ImageFromBuffer(byBitmap);

    Image NewImg = new Image();
            
    double maxX = canvas1.Width = Bitmap.Width;
    double maxY = canvas1.Height = Bitmap.Height;

    NewImg = new Image();
    NewImg.Source = Bitmap;
    NewImg.Width = Bitmap.Width;
    NewImg.Height = Bitmap.Height;
    Canvas.SetLeft(NewImg, 0);
    Canvas.SetTop(NewImg, 0);
    canvas1.Children.Add(NewImg);
}

public BitmapImage ImageFromBuffer(Byte[] bytes)
{
    MemoryStream stream = new MemoryStream(bytes);
    BitmapImage image = new BitmapImage();
    image.BeginInit();
    image.StreamSource = stream;
    image.EndInit();
    return image;
}

byte[] HexStringToBytes(string hex)
{
    return Enumerable.Range(0, hex.Length)
                 .Where(x => x % 2 == 0)
                 .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))
                 .ToArray();
}