fcim.utm.md€¦ · Author: Admin Created Date: 1/4/2020 7:35:18 PM

Universitatea Tehnică a Moldovei

SISTEM INFORMAȚIONAL DE MANAGEMENT

AL INVENTARIERII DISPOZITIVELOR

MEDICALE

Student:

Macari Mihaela

Conducător:

lect.sup. Iavorschi Anatolie

Chişinău – 2019

REZUMAT

la teza de master cu tema “Sistem de management al dispozitivelor medicale”,

Teza cuprinde introducerea, trei capitole, concluzii, bibliografia din 17 titluri, 1 anexă, 59

pagini text de bază, inclusiv 32 figuri.

Cuvinte cheie: inventariere, bază de date, limbaje de programare, proiectare, rulare

aplicație, programare Java, sistem de inventariere.

Domeniul de cercetare îl constituie aspectele teoretice şi practice ale proiectării şi

implementării funcţionale a unui sistem de management al dispozitivelor medicale, precum şi a

sintezei structurilor de înregistrare a datelor într-o bază de date.

Scopul lucrării constă în a oferi suport în simplificarea proceselor operaționale de

menținere a unei evidențe clare a dispozitivelor din stoc, de la intrarea acestora în gestiune și până

la vânzarea dispozitivelor sau utilizarea lor în interiorul companiei.

Metodologia cercetării științifice se bazează pe managementul produselor/dispozitivelor,

categoriilor, producătorilor, clienților deci și pe tehnologiile de programare orientate pe obiect.

Noutatea şi originalitatea științifică a rezultatelor obinute constă în: definirea unei noi

metode de înregistrare a datelor despre dispozitivele medicale, categoriile de dispozitive,

producătorii cu care cooperează compania, cât și despre clienții cu care are contracte compania.

Semnificaţia teoretică a lucrării o constituie elaborarea metodelor de înregistrare a datelor în baza

de date prin intermediul aplicației Windows realizate.

Valoarea aplicativă a lucrării constă în elaborarea metodelor de înregistrare a datelor în

baza de date prin intermediul aplicației Windows realizate ce se caracterizează prin păstrarea în

siguranță a datelor și fiabilitate de funcționare mai înaltă decât cele obținute prin metodele

tradiționale cunoscute. Metodele de management ale aplicației se caracterizează printr-o

complexitate mai înaltă dar mai ușor de utilizat decât cele cunoscute și asigură o implementare

eficientă pe calculatoare.

Abstract

To the master thesis with theme: “Information system for the management of medical device

inventory”,

The thesis includes the introduction, three chapters, the bibliography of 17 titles, 1 annex,

59 basic text pages, including 32 figures.

Keywords: inventory, database, programming languages, design, application run, Java

programming, inventory system.

Field of research is the theoretical and practical aspects of the design and functional

implementation of a medical device management system as well as the synthesis of the data

recording structures in a database.

Purpose of the paper consists in providing support in simplifying operational processes

to keep a clear record of stockpiles, from entry into management, to selling devices or using them

inside the company.

The methodology of scientific research is based on product / device management,

product categories, manufacturers, customers, and object oriented programming technologies.

The novelty and scientific originality of the obtained results consists of: defining a new

method of recording the data about the medical devices, the device categories, the producers with

whom the company cooperates, and about the clients with whom the company has contracts.

The theoretical significance of the work is the elaboration of the methods of data

recording in the database through the implemented Windows application.

The applicative value of the paper consists in the development of the data recording

methods in the database through the Windows application, which is characterized by the safe

keeping of the data and the higher reliability of operation than those obtained by the traditional

methods known. Application management methods are characterized by a higher but more user-

friendly complexity than known ones and provide an efficient implementation on computers.

CUPRINS

INTRODUCERE ........................................................................................................................... 1

1. PREZENTAREA ACTIVITĂȚII DE „INVENTARIERE” ÎNTR-O COMPANIE DE

COMERCIALIZARE A DISPOZITIVELOR MEDICALE ....................................................... 3

1.1. Inventarierea. Concepte generale ....................................................................................... 3

1.2. Metodologia de gestionare a depozitului ............................................................................ 5

1.3. Evidența dispozitivelor medicale într-o companie de furnizare a dispozitivelor medicale

.................................................................................................................................................... 7

1.4. Înregistrarea rezultatelor inventarierii dispozitivelor medicale........................................ 8

2. TEHNOLOGII INFORMATICE UTILIZATE LA REALIZAREA APLICAȚIEI DE

INVENTARIERE A DISPOZITIVELOR MEDICALE ............................................................ 10

2.1. Prezentare generală a unei aplicații Desktop ................................................................... 10

2.2. MySQL .............................................................................................................................. 13

2.3. JAVA ................................................................................................................................. 16

2.4. phpMyAdmin .................................................................................................................... 21

2.5. NetBeans ............................................................................................................................ 24

3. ANALIZA ȘI PROIECTAREA APLICAȚIEI PENTRU INVENTARIEREA

DISPOZITIVELOR MEDICALE .............................................................................................. 26

3.1. Scopul și obiectivele aplicației ........................................................................................... 26

3.2. Proiectarea bazei de date .................................................................................................. 27

3.3. Proiectarea practică a bazei de date ................................................................................. 30

3.4. Proiectarea interfeței de utilizator .................................................................................... 33

3.5. Utilizarea aplicației ........................................................................................................... 54

CONCLUZII ................................................................................................................................ 60

BIBLIOGRAFIE ......................................................................................................................... 62

ANEXE ........................................................................................................................................ 63

1

INTRODUCERE

Lucrarea de față își propune să justifice importanța bazelor de date în orice sector și

activitate a domeniului medical. Este oferit ca exemplu dezvoltarea unei aplicații ce utilizează o

bază de date pentru a administra activitatea oricărei firme ce activează în domeniul comercializării

dispozitivelor medicale care are un departament de depozitare a dispozitivelor medicale cât și un

departament de administrare a vânzărilor acestora.

Datele au devenit în ultimii ani cele mai importante resurse ale unei companii deoarece ele

oferă o imagine de ansamblu a activității acesteia și reprezintă baza previziunilor pentru viitor.

Astfel că datele trebuie stocate și manipulate într-un mod cât mai eficient pentru a putea oferi

răspunsuri viabile la necesitățile firmei. Deoarece ne situăm în era tehnologiei informației, orice

companie care dorește să fie eficientă trebuie să profite de avantajele oferite de utilizarea unei

aplicații informatice care simplifică munca angajaților și ajută la luarea celor mai bune decizii în

ceea ce privește activitatea firmei.

Am ales ca și domeniu economico-medical de interes, comercializarea dispozitivelor

medicale și în special domeniul inventarierii deoarece este un sector dinamic și existent din cele mai

vechi timpuri. Firmele care desfășoară activități ce presupun vânzări de dispozitive medicale au o

mare provocare în administrarea eficientă a depozitului, dar și a clienților și furnizorilor de

ispozitive medicale, astfel, este esențial ca această activitate să fie gestionată corect prin intermediul

unei aplicații informatice.

Compania în cadrul căreia a fost realizată documentarea privind departamentul de depozitare

și vânzare a dispozitivelor medicale comercializate, pe baza căreia au fost identificate elementele ce

trebuie luate în considerare la dezvoltarea aplicației este SRL Romedcom – companie specializată

distribuirea echipamentelor medicale de performanță înaltă, consumabilelor, reactivilor pentru

laborator, pieselor de schimb și mobilierului medical pentru instituțiile medico-sanitare publice,

instituții ale statului și cele private din Republica Moldova. Filosofia companiei este că aceasta pe

parcursul activității în perioada 2014-2018 au fost încheiate nenumărate contracte cu instituții

medico-sanitare publice în urma desfășurărilor licitațiilor publice deschise.

Am considerat că această companie este una relevantă pentru domeniul ales pentru

dezvoltarea aplicației, deoarece deține un depozit de dimensiuni mari, are un număr mare de

producători, dar și de clienți.Astfel anual compania efectuaiază mii de vânzări de dispozitive

medicale de toate categoriile.

2

Lucrarea este structurată în trei capitole ce realizează prezentarea domeniului ales, a

tehnologiilor informatice utilizate în realizarea aplicației de administrare a activității de inventariere

și a aplicației rezultate împreună cu modul de implementare a acesteia.

Astfel, capitolul 1 descrie activitatea de inventariere cu tot ceea ce presupune ea, punând

accent pe componenta de depozitare a dispozitivelor medicale. Este descrisă metodologia de

inventariere cât și modul de efectuare a înventarierii dar și înregistrare a datelor obținute.

Capitolul 2 prezintă tehnologiile informatice utilizate pentru realizarea programului,

accentuând punctele lor forte și justificând astfel alegerea lor.

Capitolul 3 realizează proiectarea aplicației și conține detalii tehnice referitoare la modul în

care a fost implementată aceasta. Acest capitol prezintă de asemenea aplicația și oferă indicații de

utilizare a acesteia.

3

1. PREZENTAREA ACTIVITĂȚII DE „INVENTARIERE” ÎNTR-O

COMPANIE DE COMERCIALIZARE A DISPOZITIVELOR MEDICALE

1.1. Inventarierea. Concepte generale

Inventarierea reprezintă procedeul de înregistrare a bunurilor din stoc /instituție într-un

registru de evidență a inventarierii.Prin intermediul acesteia se duce o evidență strictă asupra

bunurilor materiale aflate într-o companie/instituție puplică sau privată.

Din punctul de vedere al contabilitatii inventarierea este un procedeu de verificare faptică a

existenței și stării mijloacelor economice, a creanțelor și datoriilor unei unități patrimoniale.

Altfel spus inventarierea în cadrul unei companii de distribuire a dispozitivelor medicale reprezintă

un ansamblu de operaţiuni prin care se constată existenţa tuturor dispozitivelor din punct de vedere

cantitativ în patrimoniul sau gestiunea întreprinderii de comercializare a dispozitivelor medicale la

data la care aceasta se efectuează.

În conformitate cu “Legea despre evidenţa contabilă” agenţii economici şi instituţiile

bugetare sunt obligaţi să efectueze periodic inventarierea valorilor materiale, achitărilor şi

obligaţiunilor pentru confirmarea veridicităţii şi autentificării datelor evidenţei contabile şi de

gestiune. Obiectele şi termenele petrecerii inventarierii se determină de conducerea agenţilor

economici (instituţiilor bugetare). Modalitatea de petrecere a inventarierii patrimoniului, activelor

şi pasivelor inventariate, valorificarea şi înregistrarea rezultatelor inventarierii, precum şi

formularele utilizate la inventariere sunt descrise în “Regulamentul privind inventarierea”,

aprobat de Ministerul Finanţelor al Republicii Moldova.[17]

Scopul inventarierii constă în stabilirea situaţiei reale a patrimoniului întreprinderii de

furnizare a dispozitivelor medicale.

Conform regulamentului menționat mai sus funcțiile de bază ale inventarierii sunt:

a) stabilirea existenţei efective a mijloacelor fixe, activelor nemateriale, investiţiilor

financiare, stocurilor de produse medicale și farmaceutice cât şi materiale, mijloacelor băneşti,

volumului producţiei în curs de execuţie, creanţelor şi datoriilor etc.;

b) controlul asupra integrităţii activelor prin compararea existenţei efective cu datele din

contabilitate;

4

c) stabilirea valorilor materiale, care parţial şi-au pierdut calitatea iniţială, stilul şi modelele

învechite;

d) depistarea valorilor materiale neutilizate în scopul vânzării lor ulterioare;

e) verificarea respectării regulilor şi condiţiilor de păstrare a stocurilor de produse medicale

şi materiale, mijloacelor băneşti, precum şi a regulilor de întreţinere şi exploatare a maşinilor,

utilajelor şi a altor mijloace fixe;

f) verificarea realităţii stocurilor de produse medicale şi materiale;

Inventarul conține stocul unei gestiuni ale dispozitivelor medicale la un moment dat, la care

se pot aduce modificări după realizarea inventarului asupra mărfurilor aflate în stoc.

În acest fel se întocmește lista de inventariere de către persoana responsabilă care servește ca

document pentru înregistrarea datelor în registrul oficial de evidență a depozitului al companiei.

Registrul de evidență a depozitului reprezintă un catalog sau un document în care sunt

enumerate și descrise produsele care se află în stocul unei companii.Acesta reprezentând o listă

exactă, amănunțită cu toate detaliile referitoare la un produs.

Astfel stocurile sunt cantități de resurse materiale care se acumulează în depozitele şi

magaziile unităților economice, într-un anumit volum pentru o perioadă de timp, cu un anumit

scop.Deci stocurile reprezintă baza pe care se face inventarierea.

Reeșind din cele spuse mai sus, inventarierea într-o companie de comercializare a

dispozitivelor medicale reprezintă gestiunea stocurilor de produse aflate în depozitul companiei

respective.

Astfel inventarierea și/sau gestiunea stocurilor folosește la:

• Asigurarea continuității procesului de producție, care duce la obținerea unor venituri stabile,

prin comercializarea produselor;

• Mărirea vânzărilor.Vânzările pot fi mult mai mari, dacă bunurile sunt furnizate la timp şi în

cantităţile solicitate de către consumatori.

• Protejarea activelor unităţii economice se poate obţine prin depozitarea cantitativă şi

calitativă a materiilor prime şi materialelor.

https://facturis.ro/blog/legislatie-facturare-si-stocuri/inventar-2

5

• Investițiile minime în stocuri presupun costuri de depozitare şi de asigurare minime.

• Furnizarea de informaţii de către compartimentul de aprovizionare conducerii unităţii

economice. Aceasta se poate obţine prin determinarea cantităţilor optime de aprovizionare a

stocurilor din cadrul firmei.

• Menţinerea stocurilor de producţie a întreprinderii la nivelurile planificate.

• Păstrarea caracteristicilor calitative ale produselor pe timpul depozitării.

• Prevenirea apariţiei lipsei de stoc sau suprastocării de produse.

Altfel spus inventarierea reprezintă cea mai simplă metodă de gestiune a stocurilor.

1.2. Metodologia de gestionare a depozitului

Gestionarea depozitului reprezintă totalitatea acţiunilor de asigurare a procesului de intrare a

produselor în depozit, de menținere a evidenței în timpul aflării acestora în depozit şi de satisfacere

a nevoilor clienţilor.

Gestiunea depozitului reprezintă o necesitate, o cerinţă a activităţii economice, a procesului

de circulaţie a mărfurilor.Altfel spus aceasta este un factor decisiv pentru reuşita unei firme.

Controlul mărfurilor din depozit este necesar pentru:

• planificarea şi controlul produselor;

• controlul costurilor;

• sprijinirea clienților.

Obiectivele evidenței depozitului sunt:

• livrarea produselor cu succes;

• ieftinirea costului produselor;

• eventuale speculaţii comerciale;

• menţinerea de rezerve de stoc, în funcţie de piaţă;

• nivelarea fluctuaţiilor sezoniere ale volumului comenzilor;

6

• stocarea materialelor pentru procesul de producţie;

• asigurarea unor rezerve de stoc pentru cazuri urgente;

Rolul gestionării depozitului constă în:

• Îmbunătăţirea serviciului logistic pentru clienţi prin asigurarea disponibilităţii produselor

pentru satisfacerea cererii clienţilor interni sau externi. Nivelul de deservire reprezintă, de

fapt, capacitatea organizaţiei de a îndeplini cererea clienţilor.

Acesta este definit prin:

o durata ciclului de performantă (intervalul de timp dintre lansarea comenzii de către client

şi primirea mărfii de către acesta);

o numărul comenzilor respectate;

o cantitatea comandată.

• Echilibrul relaţiei dintre cerere şi ofertă determinat de decalajul temporal dintre acestea.

• Reducerea costurilor.

• Micșorarea incertitudinii prin faptul că prezenţa produselor în stoc protejează compania de

variaţiile neaşteptate pe termen scurt a ofertei pe piaţă şi a preţurilor practicate de furnizori.

Satisfacerea nevoilor clientului reprezintă punctul central în jurul căruia se învârt toate

activităţile realizate de companiile din orice domeniu. Fiecare manager îşi doreşte să aibă clienţi cât

mai mulţumiţi cu scopul de a-și mări vânzările. Un client mulţumit va cumpăra mai mult, va

cumpăra mai des, va cumpăra cu regularitate şi va aduce şi alţi clienţi.

Cu alte cuvinte, cu cât clientul este mai satisfăcut de serviciile sau produsele oferite, cu atât

compania care le furnizează va avea mai mult succes. Însă mulţumirea clienţilor nu depinde numai

de procesul de vânzare în sine, până a prezenta oferta clientului există multe alte procese suport care

permite companiei să aibă o vânzare de calitate. O gestionare corespunzătoare a depozitelor poate

garanta un serviciu îmbunătăţit către clienţi, ca urmare a eficienţei obţinute.

De aceea, în vânzari firma nu trebuie să se limiteze doar la un serviciu excelent de relaţionare

cu clienţii. Trebuie să acorde o atenţie deosebită tuturor activităţilor care au loc în firmă deoarece

7

toate aceastea conduc către un serviciu de calitate către clienţi.Este imposibil să obţii aceste lucruri

fără o gestiune corectă şi eficientă a depozitului.

Gestiunea stocurilor/depozitelor impune atenţia specială a conducerii companiei, deoarece acest

subiect include aspecte financiare legate de producţie, transport, asigurare etc. De asemenea,

managementul corect al stocului poate facilita livrarea producţiei cu calitatea necesară, la timpul

dorit şi la preţ rezonabil.

Gestionarea eficientă a stocurilor este importantă din următoarele motive: • asigură urmărirea în ansamblu a dinamicii stocurilor la nivelul companiei;

• exprimă nivelul relațiilor companiei cu furnizorii și clientii săi;

• permite cunoașterea riscurilor pe întreg lanțul logistic: furnizor, aprovizionare, desfacere

clienți;

• permite identificarea rapidă a unor măsuri în cazul lipsei de materiale;

Managementul depozitelor oferă soluţii eficiente prin implementarea unui sistem informatic de

gestionare care oferă informaţii în timp real. Un sistem informatic de gestiune ajută la

monitorizarea stocurilor şi implicit la optimizarea stocului, uşurează inventarul şi elimină cauzele

care generează pierderi de informaţii.

1.3. Evidența dispozitivelor medicale într-o companie de furnizare a dispozitivelor

medicale

Evidența dispozitivelor medicale într-un depozit constă în exercitarea controlului şi

asigurarea realizării prevederilor actelor normative în vigoare în domeniul activităţii desfăşurate de

către întreprinderile furnizoare de dispozitive medicale.

Astfel registrul de evidență asigură:

• organizarea și realizarea controlului planificat ale dispozitivelor/produselor aflate în

stoc;

• exercitarea funcției de control la etapa de primire a dispozitivelor;

• evidența, păstrarea în siguranță a dispozitivelor;

8

• verificarea respectării și corespunderii cerințelor tehnice înainte de livrarea

dispozitivelor;

Evidența dispozitivelor medicale constă în identificarea și numărarea dispozitivelor

medicale, suprapunerea datelor existente în contabilitate (care nu vor fi complete), și verificarea cu

lista dispozitivelor existentă în companie.

În acest fel în lista de inventariere se introduc date despre:

• denumirea dispozitivului;

• categorie;

• producător;

• model;

• descriere;

• preț;

• cantitate;

• garanție;

La finisarea listei de inventariere toate totalurile se înscriu în registru de evidență.

1.4. Înregistrarea rezultatelor inventarierii dispozitivelor medicale

Conducătorul întreprinderii poartă răspundere de corectitudinea şi oportunitatea efectuării

inventarierii.Conducerea întreprinderii este obligată să creeze condiţiile, care asigură un control

complet şi exact al existenţei reale a dispozitivelor/produselor.

Stabilirea rezultatelor inventarierii presupune:

* Compararea efectivă a stocurilor din listele de inventariere cu stocurile din contabilitate.

* Pentru lipsurile constatate la dispozitivele medicale, conducătorii întreprinderii trebuie să

primească explicaţii scrise de la persoanele care au răspundere materială deplină, gestionarii.

9

* Pe baza explicaţiilor primite comisia de inventariere stabileşte caracterul lipsurilor, pierderilor,

pagubelor constatate propunînd, în conformitate cu dispozițiile legale, modul de regularizare a

diferenţelor dintre datele din contabilitate și cele faptice, rezultate în urma inventarierii.

*Erorile descoperite se corectează;

Gestionarii depozitului după efectuarea inventarierii înregistrează datele în sistemul de management

al dispozitivelor medicale;

10

2. TEHNOLOGII INFORMATICE UTILIZATE LA REALIZAREA

APLICAȚIEI DE INVENTARIERE A DISPOZITIVELOR MEDICALE

În continuare vor fi prezentate tehnologiile utilizate pentru realizarea aplicației de

management a inventarierii dispozitivelor medicale.Trebuie precizat că aplicația va fi una desktop.

2.1. Prezentare generală a unei aplicații Desktop

Aplicaţiile desktop sunt acele aplicaţii care se execută independent pe calculatoarele desktop sau pe

laptop.

Aplicațiile desktop sunt foarte fiabile, oferind încredere utilizatorului. Acestea pot fi

accesate de pe orice computer de tip desktop sau laptop, dacă au fost în prealabil instalate pe

acestea. Astfel de aplicații nu au nevoie de o conexiune la internet stabilă, ele functionând

încontinuu pe PC, chiar și fără internet.

Un dezavantaj ar fi faptul că aplicația respectivă nu poate fi folosită și pe alt PC, dacă nu

este instalată acolo.

Caracteristicile aplicațiilor desktop:

• Aplicațiile desktop tind să aibă mai multe caracteristici și să realizeze diferite sarcini.

• Ele merg foarte bine doar atunci când sunt utilizate cu un mouse și o tastatură.

• În Windows 10 și în Windows 8.1, acestea sunt executate cu permisiuni limitate dar pot

primi drepturi de administrator de la utilizator. Unele aplicații desktop, precum programele

de securitate, nu pot funcționa corect fără permisiuni de administrator.

• Programele pot rula în instanțe multiple, în paralel. De exemplu, poți deschide aceeași

aplicație desktop de două, trei sau mai multe ori și poți lucra cu fiecare instanță în paralel.

Pe un calculator cu mai multe monitoare, poți afișa orice instanță pe orice monitor sau toate

instanțele programului pe toate monitoarele.

• Aplicațiile desktop pot fi folosite în orice versiune de Windows: Windows 10, Windows 8.1,

Windows 7, Windows Vista sau Windows XP. Dar, unele s-ar putea să nu fie compatibile cu

versiuni vechi de Windows, în funcție de cum au fost programate.

• Ele pot instala servicii de Windows care le oferă acces la diferite resurse de sistem și

execută sarcini complexe de lucru în beneficiul utilizatorului.

11

• Aplicațiile desktop pot avea orice fel de conținut. Ele nu sunt moderate și aprobate de

Microsoft.

• Programele pot fi distribuite așa cum dorește dezvoltatorul lor. De asemenea, ele pot fi

instalate din orice sursă: site-uri web, discuri de instalare, stick-uri USB, etc.

• Aplicațiile desktop instalate sunt listate în "Panoul de Control->Programe -> Programe și

Caracteristici" și pot fi dezinstalate din această locație.

• Programele pot fi actualizat manual de către utilizator ori automat, prin servicii de

actualizare create pentru acest scop de dezvoltatorii lor sau prin aplicații din terțe părți.

• Actualizările aplicațiilor desktop nu sunt mereu gratuite. Dezvoltatorul unei aplicații desktop

poate cere o taxă pentru actualizarea la cea mai nouă versiune.

• Aplicațiile desktop pot avea orice model de licențiere: de la modele proprietare la licențe

open-source.

• Ele nu trebuie să îndeplinească anumite cerințe care vin din partea Microsoft, exceptând

scenariul în care sunt distribuite prin Magazinul Windows. Singurele cerințe pe care trebuie

să le respecte sunt cele impuse de dezvoltator.

• Programele funcționează pe sisteme cu procesoare Intel și AMD, care folosesc arhitectura

x86.

Cu siguranţă, noţiunea de aplicaţii desktop merită explicaţii detaliate. Dacă respectăm definiţiile

deja stabilite, putem spune că aplicaţiile desktop sunt acele aplicaţii care se execută independent pe

calculatoarele desktop sau pe laptop. Un exemplu tipic de aplicaţie desktop este procesorul de

text Microsoft Word, pe care îl puteţi vedea în imaginea 2.1.

https://www1.link-elearning.com/linkdl/opisPojma.php?id=139560

12

2.1 – Microsoft Word – aplicaţia desktop

Mai demult, noţiunea de aplicaţie desktop se folosea pentru a face deosebirea între noţiuni precum

aplicații desktop şi aplicaţii web. Astăzi situaţia s-a complicat, din cauza apariției unor noi tipuri de

aplicaţii, precum aplicaţiile pentru dispozitivele mobile.

În gama de produse şi tehnologii Microsoft situaţia este și mai complicată. Odată cu apariţia

sistemului de operare Windows 8, a apărut şi un nou tip de aplicaţii. La început, acest nou tip de

aplicaţii s-a numit Metro style Apps, pentru ca în final să se opteze pentru titlul Store Apps. Este

vorba de aplicaţii care funcţionează exclusiv în modul ecran complet şi sunt adaptate sistemelor cu

touch screen.

2.2 – Windows 8, Store Apps

https://www1.link-elearning.com/linkdl/opisPojma.php?id=139561

13

Windows 10 a introdus încă o noţiune nouă - Universal Apps. Este vorba despre aplicaţiile

care pot funcţiona pe un spectru larg de dispozitive, de la telefoane mobile și tablete, până la

calculatoare portabile şi desktop.

2.3 – Aplicaţiile Universall

Tehnologii pentru dezvoltarea aplicaţiilor desktop pentru Windows

Ca să creăm aplicaţii desktop pentru sistemele de operare Windows, echipa de dezvoltare

are la dispoziție câteva tehnologii disponibile. Alegerea unei combinații potrivite de tehnologii

depinde, în cea mai mare măsură, de scopul aplicaţiei şi de cererile de utilizator.

În acest fel se utilizează limbajele de programare Java, C#, C++ și altele împreună cu medii

de programare precum: Visual Studio, NetBeans, Eclipse și altele.

2.2. MySQL

MySQL este un sistem destinat gestionării bazelor de date. El este al doilea sistem de acest

tip care se foloseşte cel mai frecvent (în august 2014), fiindcă este cel mai folosit sistem pentru

gestionarea bazelor SQLite, care iniţial este instalat cu fiecare telefon Android şi iPhone, precum şi

cu fiecare browser Firefox şi Chrome.

MySQL este un proiect cu cod deschis, creat de compania suedeză MySQL AB, aceasta

fiind în proprietatea Oracle. Cuvântul My din denumire se referă la numele fiicei coautorului

Michael Widenius, în timp ce SQL este prescurtarea de la Structured Query Language.MySQL se

livrează fără niciun instrument cu interfață grafică pentru utilizator pentru manipularea datelor.

Utilizatorii pot folosi consola integrată, respectiv command interface (CLI) sau pot folosi unul

dintre instrumentele cu mediu de utilizator grafic, care se poate procura independent de sistemul

MySQL.

14

MySQL este strâns legat de Java, împreună formând așa-numitul Duo-Dinamic, folosit la

majoritatea aplicațiilor desktop existente. Deși, de cele mai multe ori este utilizat alături de JAVA,

MySQL permite construirea de aplicații în orice limbaj major de programare (C, C++, PHP, Perl,

Python). Administrarea bazelor de date MySQL se poate face atât folosind modul linie de

comandă, cât și prin intermediul unor interfețe grafice precum: MySQL Administrator, MySQL

Workbench sau phpMyAdmin.

Principalele caracteristici ale MySQL sunt:

• faptul că este un sistem de baze de date relațional;

• arhitectura client/server: mysql lucrează ca un server de baze de date la care se pot

conecta mai mulți clienți (programe de aplicație). Clienții pot rula pe aceeași mașină

fizică sau pot fi localizați pe un alt calculator, comunicând prin rețeaua locală sau

prin Internet;

• compatibilitatea SQL: după cum reiese și din denumirea sa, este folosit limbajul de

baze de date SQL, ca și limbaj standardizat pentru interogarea și actualizarea datelor;

• viteza: MySQL este considerat una dintre cele mai rapide aplicații de lucru cu bazele

de date;

• independența de platformă: aplicațiile client pot rula pe o varietate de sisteme de

operare, iar MySQL ca și server poate de asemenea să fie executat pe platforme

precum: Apple ș Mac OS X, Linux, Microsoft Windows, dar și alte variante de Unix,

cum ar fi: AIX, ș BSDI, FreeBSD, HP-UX, Open BSD sau Solaris.

O altă caracteristică importantă a lui MySQL este faptul că poate rula pe platforme cloud

cum ar fi Amazon EC2, existând mai multe posibilită pentru realizarea acestei facilită precum:

utilizarea unei mașini virtuale cu MySQL instalat, sau oferirea de servicii MySQL de către

operatorul de găzduire.

MySQL are atât puncte forte cât și puncte slabe, “Mulți fani înrăiți ai lui MySQL spun că

acest SGBD este mai rapid, mai de încredere și mai ieftin, sau pur și simplu mai bun, decât orice alt

sistem de gestiune a bazelor de date (inclusiv sistemele comerciale precum Oracle sau DB2), în

timp ce multi oponenți ai MySQL spun chiar că nu este nici măcar un sistem de baze de date

relațional”. În ceea ce privește aplicația prezentată în această lucrare, pot spune că MySQL ocupă

15

unul din cele mai importante roluri pentru realizarea ei în primul rând datorită faptului că este

prelucrat un set de date de dimensiune mare, iar accesul la aceste date trebuie să fie cât se poate de

rapid și corect. MySQL, împreună cu JAVA realizează operațiile de regăsire, actualizare, inserare și

tergere a datelor.

Elementele mediului MySQL

Ceea ce se știe până acum este că bazele de date se folosesc pentru introducerea, respectiv

stocarea datelor, că sistemele care ne asigură manipularea bazelor şi a datelor se numesc DBMS şi

că un limbaj concret cu care realizăm cele menţionate este SQL.

Putem spune că mediul MySQL este alcătuit din două părţi, din serverul care gestionează

datele şi client, cel din urmă solicitând de la server executarea anumitor operaţii. De fapt, pe

sistemele de operare Windows, serverul este doar un serviciu care este capabil să primească

comenzi şi să execute stocarea datelor. Pe de altă parte, clientul este fiecare software care ştie cum

trebuie interogat serverul pentru a executa operaţiile dorite asupra bazelor şi a datelor.

Atunci când o bază de date este folosită într-o aplicaţie, fie aceasta o aplicaţie web, desktop

sau una mobilă, atunci aplicaţia devine clientul bazei de date. Pentru ca aplicaţia, pe care o

dezvoltăm singuri, să fie capabilă să se înţeleagă cu serverul MySQL, respectiv să recunoască

limbajul lui, există aşa-numiţii Conectori (Connectors) care se deosebesc în funcţie de platformă şi

de limbajul de programare care se va folosi. Aceștia sunt, de fapt, biblioteci scrise în limbajul-sursă

pentru care sunt destinate şi care conţin metode finalizate pentru comunicare.

16

Figura 2.4 Interacţiunea aplicaţiilor de client şi a serverului MySQL

2.3. JAVA

Java este un limbaj de programare multifuncţional, ale cărui caracteristici principale sunt

portabilitatea, simplitatea, orientarea pe obiecte şi fiabilitatea. Acest limbaj nu este strict legat de un

sistem de operare, nici de un tip de aplicaţie, astfel încât poate fi executat pe majoritatea

dispozitivelor. Java este un limbaj pentru scrierea programelor, dar și o platformă pentru rularea

programelor scrise în Java și a altor limbaje de programare (de exemplu, Groovy, Clojure, Scala sau

în implementări ale altor limbaje în Java, spre exemplu Jython sau JRuby). Spre deosebire de

platformele fizice care sunt alcătuite din procesoare și sisteme de operare, platforma Java constă

dintr-un singur tip de procesor software responsabil de executarea programului Java.

17

2.5 – Logo-ul Java

Istoric

Povestea programului Java începe în 1991 când James Gosling a început să lucreze la

limbajul de programare Oak. În anul următor, Sun Microsystems a prezentat Star7, un dispozitiv

PDA cu ecran tactil și interfață de utilizator grafică animată, pe care a debutat Oak, un limbaj de

programare cu procesor independent, scris cu un an înainte special pentru acest dispozitiv.

Dispozitivul a trecut aproape neremarcat.Limbajul de programare Oak și-a schimbat numele în Java

în 1995.

Acest limbaj de programare a apărut din nevoia de a avea un limbaj de programare cu

platformă independentă care să poată fi folosit la dezvoltarea unui software pentru dispozitivele

electronice de larg consum, precum prăjitoarele de pâine, cuptoarele cu microunde și telecomenzile.

După cum poate ați ghicit deja, în această diversitate de dipozitive, diferite tipuri de procesoare apar

sub formă de controlere. Exact aceasta a fost şi problema, deoarece în momentul în care a fost creat

Java, majoritatea limbajelor de programare erau proiectate pentru a fi implementate pe o platformă

specifică. Dacă luăm ca exemplu C++, putem vedea că deși era posibil să compilăm programul C++

pe orice tip de procesor, acesta necesita dezvoltarea unui compilator C++ complet pentru platforma

țintă, ceea ce constituie un proces foarte costisitor și îndelungat. Încercând să rezolve problemele

menționate mai sus, Gosling și echipa sa de la Sun au lucrat la dezvoltarea unui limbaj de

programare portabil, cu platformă independentă, ceea ce a dus la crearea limbajului Java.

În momentul în care a fost creat Java, World Wide Web cunoștea o dezvoltare intensă care a

avut o influență crucială asupra formării și poziționării limbajului Java ca limbaj de programare.

Dacă Web-ul nu s-ar fi dezvoltat așa cum a făcut-o în momentul în care a apărut Java, acest limbaj

18

ar fi rămas probabil o tehnologie utilă, dar nu atât de revoluționară, care s-ar fi folosit doar în

industria electronicelor de larg consum. Odată cu „explozia” Internetului, Java a intrat în prim-plan,

deoarece Web-ul avea nevoie de portabilitatea oferită de Java. Deși nevoia de a crea limbaje de

programare portabile cu platformă independentă este la fel de veche ca și programarea însăși,

această problemă nu a fost considerată una importantă până când Internetul nu a devenit un

fenomen în masă. Internetul aduce cu sine o nouă rețea alcătuită din diferite computere, sisteme de

operare și procesoare. Ceea ce nu era considerat o problemă importantă a devenit una. Creatorii

programului Java, văzând că problemele pe care le întâlneau în încercările lor de a proiecta un

limbaj cu platformă independentă pentru produsele electronice de larg consum apăreau și în rețeaua

globală, au decis să se concentreze asupra Internetului. Astfel, putem spune că, pe lângă

independența platformei, şi Internetul este responsabil pentru marele succes al lui Java.

Cum funcționează JAVA?

Viața unui program Java începe sub forma unui cod sursă scris de un programator. În acest

scop, putem folosi un simplu editor de text. Un fișier care conține codul sursă Java are extensia

.java. Următorul pas constă în compilarea codului sursă, lucru care se efectuează cu un compilator

Java (javac). În urma compilării, obținem un fișier cu extensia .class. Conținutul acestui fișier se

numește bytecode. Bytecode este un limbaj similar din punct de vedere sintactic cu codul mașină,

dar necesită o interpretare adițională pentru a fi transformat în limbajul sursă (mașină) al mediului.

Această sarcină este efectuată de JVM. Astfel, obținem portabilitatea multiplatformă a programului.

Cu alte cuvinte, odată scris un cod poate fi executat pe o platformă diferită folosind JVM (Java

Virtual Machine) pornit pe acel sistem.

2.6 Ciclul de viață al programului Java

Executarea unui program (fără nicio legătură cu Java) are loc întotdeauna în două forme:

interpretarea sau executarea codului compilat. Interpretarea înseamnă traducerea și executarea

codului în timp real, în timp ce compilarea înseamnă că acest cod va fi mai întâi interpretat în

19

limbajul sursă al mediului și apoi, în timpul executării, codul va fi pornit în forma sa interpretată de

fiecare dată. De aici, putem concluziona că executarea programelor compilate anterior este mai

rapidă decât executarea celor interpretate. Modul în care funcționează Java este un amestec între

executarea interpretată și cea tradusă. Codul sursă este tradus în bytecode, apoi bytecode-ul este

interpretat într-un cod mașină specific. Singura premisă necesară pentru ca Java să funcționeze într-

un mediu este existența unui JVM (Java Virtual Machine) în acel mediu. Java Virtual Machine

reprezintă un tip de procesor software cu un set de instrucțiuni. Este alcătuit dintr-un număr uriaș de

biblioteci cu funcții predefinite, cunoscute sub numele de biblioteci de clase standard care pot fi

folosite de un program scris în Java ca să efectueze operații de rutină. De asemenea, JVM posedă și

așa-numitul cod „glue” care ajută la obținerea interacțiunii cu sistemul de operare unde este instalat

JVM.

Java Virtual Machine poate fi găsit în JRE și JDK. Veți întâlni des aceste abrevieri în

universul Java. JRE (Java Runtime Environment) permite sistemului de operare să execute

programe scrise în limbajul Java, în timp ce JDK (Java Development Kit) aduce, pe lângă mediul

de inițializare a lui Java, şi un set de instrumente utilizate de programatori pentru a dezvolta

aplicații. JRE conține JVM și un set de biblioteci variate cu funcții predefinite care pot fi folosite de

aplicații, iar JDK conține JRE și instrumente de programare.

Figura 2.7 Structura mediului Java

În imaginea de mai sus, putem vedea că în JVM există și JIT (Just In Time Compiler). Se

folosește pentru a accelera interpretarea codului (lucru pe care îl face prin recunoașterea comenzilor

repetate des) și pentru a efectua traducerea acestor comenzi în timpul executării programului. Ciclul

de viață complet al lui Java este afișat în imagine.

20

2.8. Modul de operare a lui Java

Edițiile Java

Deşi Java nu este dependent de platformă, există totuşi diferite ediţii şi forme ale executării

sale: Java Standard Edition, Enterprise Edition şi Micro Edition. Aceste ediţii au aceeaşi bază,

dar diferă prin seturi adiţionale de biblioteci specializate pentru anumite domenii. Standard Edition

cunoaşte aplicarea cea mai largă şi se foloseşte pentru crearea diferitelor tipuri de aplicaţii desktop.

Enterprise Edition este menită creării unor aplicaţii de server robuste care includ şi servicii Web

XML, aplicaţii Web distribuite etc. Micro Edition este menită producerii aplicaţiilor pentru

telefoane mobile şi alte dispozitive manuale şi mobile, despre care se presupune că nu au o putere

de executare analoagă platformelor desktop şi server.

Compania Sun, autorul oficial al limbajului Java, a schimbat în 1998 numele acestui limbaj

din Java 1.2 în Java 2 (J2), motiv pentru care ediţiile menţionate se numesc prescurtat J2SE, J2EE

şi J2ME. În 2006, din motive de marketing, edițiile și-au schimbat numele în Java SE, Java EE și

Java ME, care sunt în vigoare și astăzi.

Tehnologiile Java

Există diverse tehnologii susţinute de Java. Cu ajutorul acestui limbaj, putem crea aplicaţii

desktop multiplatform, aplicaţii web, aplicaţii pentru dispozitive mobile, aplicaţii web RIA etc. În

21

general, cu ajutorul lui Java şi cu un mediu adecvat putem crea orice tip de aplicaţie. Când vorbim

despre aplicaţii desktop GUI (Graphic User Interface), se subînţelege folosirea tehnologiilor AWT

(Abstract Window Toolkit), respectiv JFC (Java Foundation Classes) şi Swing. Deşi au mecanisme

de funcţionare complexe, aceste sisteme pot fi gestionate simplu cu ajutorul unui mediu grafic care

creează majoritatea acestor componente pentru noi când, pur şi simplu, tragem controalele în

aplicaţie.

Java susţine şi tehnologii de realizare a diferitelor tipuri de aplicaţii web: aplicaţii standard,

aplicaţii client-server, servicii web, aplicaţii RIA (Rich Internet Applications) etc. În acest scop

folosim tehnologia JSP (Java Server Pages) care este analoagă tehnologiilor web de server, cum ar

fi PHP şi ASP. În general, JSP subînţelege implementarea codului Java în codul HTML pentru a

asigura dinamica creării documentelor web. Un scop similar îl are şi tehnologia Java Servlet care

subînţelege clasa Servlet pentru crearea documentelor web. Spre deosebire de JSP, Servlet nu

implementează codul Java în documente HTML, ci sunt reprezentate exclusiv prin codul Java.

Pentru producerea părţilor de client ale aplicaţiilor web se folosesc Java Applets şi JavaFX.

Ambele tehnologii subînţeleg sisteme încapsulate, independente de codul HTML, asemănătoare cu

Adobe Flash şi Microsoft Silverlight. Deşi, în contextul Java, pentru crearea aplicaţiilor web se

foloseşte cel mai frecvent o combinaţie de JavaScript, HTML şi JSP. În caz că e nevoie de

conţinuturi grafice mai avansate, se folosesc Java Applets şi JavaFX.

Mediul de dezvoltare Java

Java nu este dependent de mediul de dezvoltare, deoarece codul sursă al aplicațiilor Java

este plasat în documente textuale obișnuite, iar pentru a crea un program Java nu avem nevoie decât

de un compilator Java (javac application). Acest program, împreună cu celelalte programe necesare

pentru crearea unei aplicaţii Java se află în setul JDK (Java Development Kit). Deşi pentru a folosi

Java nu avem nevoie de o aplicaţie de dezvoltare mai bună decât Notepad, cel mai adesea,

aplicaţiile Java serioase nu se scriu în el, ci în medii de dezvoltare predefinite. Două dintre cele mai

populare sunt Eclipse şi NetBeans. Ambele sunt gratuite şi scrise în Java, fiind prin urmare cu

platformă independentă. În acest curs, vom folosi NetBeans, pe platforma Windows.

2.4. phpMyAdmin

phpMyAdmin reprezintă un sistem de gestionare a bazelor de date MySQL liber, open source, scris

în PHP și destinat administrării bazelor de date prin intermediul unui browser web. Prin intermediul

mediului phpMyAdmin se pot întreprinde diferite operații cum ar fi crearea, modificarea sau

https://ro.wikipedia.org/wiki/Sistem_de_gestiune_a_bazelor_de_date

https://ro.wikipedia.org/wiki/MySQL

https://ro.wikipedia.org/wiki/Software_liber

https://ro.wikipedia.org/wiki/Open_source

https://ro.wikipedia.org/wiki/PHP

https://ro.wikipedia.org/wiki/Baz%C4%83_de_date

https://ro.wikipedia.org/wiki/Browser_web

22

ștergerea bazelor de date, tabelelor, câmpurilor sau rândurilor; executarea de comenzi

(interogări) SQL.

Acesta este o unealtă scrisă în PHP cu scopul de a administra baze de date MySQL pe web.

Poate crea/șterge/modifica tabele, câmpuri, executa interogări SQL, administra privilegii și exportă

datele în diverse forme.

phpMyAdmin vine cu o gamă largă de documente și utilizatorii sunt bineveniți să

actualizeze paginile wiki pentru a împărtăși idei și modalități pentru diverse operațiuni. Echipa

phpMyAdmin va încerca să vă ajute dacă vă confruntați cu orice problemă; puteți utiliza o varietate

de canale de asistență pentru a obține ajutor.phpMyAdmin este, de asemenea, foarte documentat

într-o carte scrisă de unul dintre dezvoltatori - Mastering phpMyAdmin pentru gestionarea eficientă

a MySQL, disponibil în engleză și spaniolă.Pentru a ușura utilizarea de către mai multe persoane,

phpMyAdmin este tradus în 72 de limbi și acceptă limbile LTR și RTL.

phpMyAdmin este un proiect matur cu o bază de cod stabilă și flexibilă; puteți afla mai

multe despre proiect și istoria sa și despre premiile pe care le-a câștigat. Când proiectul a împlinit

15 ani, am publicat o pagină de sărbători.Proiectul phpMyAdmin este membru al Software Freedom

Conservancy. SFC este o organizație non-profit care ajută la promovarea, îmbunătățirea,

dezvoltarea și apărarea proiectelor Free, Libre și Open Source (FLOSS).

Caracteristici

• Interfață web intuitivă;

• Suport pentru majoritatea funcțiilor MySQL;

• server de întreținere, baze de date și tabele, cu propuneri privind configurarea serverului;

• permite executarea, editarea și marcarea oricărei instrucțiună SQL;

• gestionarea conturile de utilizator MySQL și privilegiilelor;

• gestionarea procedurilor și declanșatoarelor stocate;

• Importarea datelor din CSV și SQL;

• Exportarea datelor în diverse formate: CSV, SQL, XML, PDF, ISO / IEC 26300 - Text și

Foaie de calcul OpenDocument, Word, LATEX și altele;

https://ro.wikipedia.org/wiki/SQL

23

• Administrarea mai multor servere;

• Crearea grafică a aspectului bazei de date în diferite formate;

• Crearea de interogări complexe utilizând Query-by-example (QBE);

• Căutarea globală într-o bază de date sau un subset al acesteia;

• Transformarea datelor stocate în orice format utilizând un set de funcții predefinite, cum ar

fi afișarea datelor BLOB ca imagine sau descărcare;

Această aplicație permite crearea unei DB de la zero, crearea tabelelor, realizarea operațiilor dorite

asupra acestora și exportarea lor pentru publicarea pe server sau pentru scopuri de backup local.

PhpMyAdmin este cea mai populară interfață de administrare a bazelor de date MySQL.

Această aplicație constă dintr-un set de scripturi PHP grupate, uzual, într-un director cu același

nume, care este la rândul sau un subfolder al folderului care constituie rădăcina sistemului de fișiere

și foldere oferite în Web. În cazul serverului Web Apache pentru Windows, instalat de obicei în

C:Apache, folderul oferit în Web este C:Apachehtdocs. Folderul phpMyAdmin este un subfolder al

acestuia.

Argumente pro pentru folosirea phpMyAdmin:

• acces usor de pe orice calculator;

• un set robust de caracteristici;

• export și import SQL cu un numar rezonabil de opțiuni;

• operații ușor de accesat la nivel de tabel cum ar fi: redenumire, mutare date;

• unelte simple pentru copiere dintr-un tabel în altul sau dintr-o bază de date în alta;

• set complet de operații legate de interogare (mergând până la stocarea și accesarea lor

ulterioară);

24

2.5. NetBeans

NetBeans este un proiect open-source, cu o bază de utilizatori foarte mare, o comunitate în

creştere şi peste 100 de parteneri (în creştere!) din toată lumea. Sun Microsystems a fondat proiectul

open source NetBeans în iunie 2000 şi continuă să fie principalul sponsor al proiectului.Astăzi

există două produse: NetBeans IDE şi platforma NetBeans.

NetBeans IDE este un mediu de dezvoltare - un instrument pentru programatori, pentru

scrierea, compilarea, testarea, depanarea, proiectarea şi instalarea programelor. Este scris în Java -

dar poate accepta orice limbaj de programare. De asemenea, există un număr imens de module

pentru extinderea NetBeans IDE. NetBeans IDE este un produs gratuit, fără restricţii legate de

modul de utilizare. De asemenea, este disponibilă Platforma NetBeans; o bază modulară şi extensibilă,

utilizată drept conector software pentru crearea aplicaţiilor desktop puternice. Partenerii ISV oferă

Plugin-uri cu valoare adăugată, care se integrează uşor în platformă şi care pot fi utilizate, de

asemenea, la dezvoltarea propriilor instrumente şi soluţii.

Ambele produse sunt open-source şi gratuite pentru uz comercial şi necomercial. Codul

sursă este disponibil pentru reutilizare, conform Common Development and Distribution License (CDDL -

Licenţa de distribuţie şi dezvoltare comună).

Acest program este, de câţiva ani încoace, unul dintre cele mai puternice instrumente pentru

gestionarea limbajului Java, fiind susţinut de marea parte a comunităţii Java. NetBeans a început ca

un proiect studenţesc a doi studenţi cehi, în anul 1996, fiind primul mediu de programare pentru

Java, scris chiar în Java. Aplicaţia a fost suficient de utilă pentru a interesa comunitatea de

programatori Java într-o asemenea măsură încât au început să contribuie singuri la dezvoltarea ei,

scriind Plug-in-uri. În 1999 NetBeans a devenit mediul oficial de dezvoltare pentru Java, acceptat

de compania Sun Microsystems.

Un proiect open source este o entitate vie care are nevoie de timp pentru a găsi echilibrul

corect al oamenilor. Dezvoltarea sa este întotdeauna un proces continuu. În primul an (prin

NetBeans 3.2), proiectul a fost lansat. Următorii câțiva ani au implicat învățarea despre ceea ce a

funcționat în termenii proceselor open-source. (În primii doi ani, procesul de dezvoltare a fost atât

de deschis încât mai mult timp a fost cheltuit în dezbateri decît în punerea în aplicare). Cu NetBeans

3.5, au fost făcuți pași importanți în performanță, au fost efectuate teste și procese pentru a preveni

regresiile. Cu 3.6, sistemul de ferestre și tabloul de proprietăți au fost reimplementate, iar interfața

cu utilizatorul a fost curățată foarte mult. NetBeans 4 a reprezentat o schimbare completă în modul

https://netbeans.org/features/ide/index.html

https://netbeans.org/features/platform/index.html

https://netbeans.org/cddl.html

25

în care IDE a funcționat. Un nou sistem de proiect nu numai că a îmbunătățit experiența

utilizatorului, dar a făcut posibilă înlocuirea infrastructurii care a reținut NetBeans înapoi. NetBeans

4.1 a fost construită pe noua infrastructură de proiect de 4.0 și a adăugat mai multe caracteristici și

suport complet J2EE. NetBeans 5 a introdus suport complet pentru dezvoltarea modulelor IDE și a

aplicațiilor client bogate bazate pe platforma NetBeans; un constructor grafic intuitiv (Matisse);

suport nou și reproiectat CVS; suport pentru Sun ApplicationServer 8.2, Weblogic 9 și JBoss 4.

NetBeans 6 s-a axat pe îmbunătățirea productivității dezvoltatorilor printr-un editor rescris, mai

inteligent și mai rapid, împreună cu integrarea produselor NetBeans externe într-un singur IDE.

NetBeans 7 a fost lansat împreună cu JDK 7, oferind instrumente editor pentru lucrul cu noile

constructori de limbi JDK 7, împreună cu suport pentru JavaFX 2.0, 7.1, o serie de îmbunătățiri de

performanță în întreaga IDE în 7.2 și suport pentru aplicațiile HTML5 în 7.3. Eliberările ulterioare

au continuat să se bazeze pe succesul lansărilor anterioare și pe cerințele unei industrii în schimbare.

Au fost promovate conferințele de presă, premiile din industrie și recenziile favorabile ale

dezvoltatorilor. Astăzi, echipa NetBeans nu a putut fi mândră de cât de departe a venit proiectul și

comunitatea NetBeans. De asemenea, trebuie remarcat faptul că mulți dintre arhitecții originali sunt

încă implicați în proiect și pot fi găsiți participanți pe listele de discuții NetBeans. Există mai mulți

oameni care folosesc software-ul NetBeans decât oricând, în 2010 a fost atinsă marca de utilizator

activă de 1.000.000. NetBeans IDE continuă să se îmbunătățească, în timp ce comunitatea crește

într-un clip rapid.

26

3. ANALIZA ȘI PROIECTAREA APLICAȚIEI PENTRU INVENTARIEREA

DISPOZITIVELOR MEDICALE

3.1. Scopul și obiectivele aplicației

Aplicația a fost creată cu scopul de a oferi suport în simplificarea proceselor operaționale și

în ținerea unei evidențe clare a produselor din stoc, de la intrarea acestora în gestiune și până la

vânzarea produselor sau utilizarea lor în interiorul companiei.

Obiectivele aplicației sunt:

• evidența clară și explicită adispozitivelor din depozit;

• inventarierea dispozitivelor medicale;

• eficientizarea administrării depozitului;

• oferirea unei viziuni de ansamblu asupra situației din interiorul depozitului;

• reducerea numărului de procesări a documentelor;

• oferirea unui proogram-suport pentru angajații companiilor de comercializare a

dispozitivelor medicale;

• reducerea costurilor cu personalul;

• implementarea unui sistem informatic modern în companie;

• creșterea nivelului profesional al angajaților datorat utilizării aplicației moderne;

În figura 3.1 se poate observa fluxul informațional ce stă la baza aplicației.

În acest fel după introducerea datelor acestea pot fi modificate și eliminate din baza de

date.În plus, datele pot fi consultate atât în starea lor inițială cât și după ce au fost editate.

Deci obiectivul final al acestui sistem este managementul simplu al categoriilor de

dispozitive medicale, al dispozitivelor aflate în depozitul companiei, al producătorilor/furnizorilor

cu care cooperează compania și al clienților cu care are contracte compania.

27

Figura 3.1 Fluxul informațional al aplicației

Funcționalități de bază:

• Permite adăugarea datelor;

• Permite editarea datelor;

• Permite eliminarea datelor;

• Permite vizualizarea datelor introduse;

Această aplicație reprezintă o soluţie inteligentă de inventariere a dispozitivelor medicale în

cadrul companiilor de vânzări a acestor produse.

Asigură o monitorizare și o gestionare eficientă a stocurilor unei companii indiferent de numarul

de produse, furnizori și clienți.

Oferă posibilitatea de gestionare a depozitului dar și de menținere a evidenței producătorilor și

clienților cu care se lucrează.

Este managerul perfect pentru inventariere.

3.2. Proiectarea bazei de date

Proiectarea bazei de date presupune cunoașterea problemei ce trebuie rezolvată de către

aplicație și în primul rând cunoașterea datelor ce trebuie reținute (dimensiune, tipologie, etc).În

primul rând, trebuie precizat faptul că realizarea unei aplicații cu baze de date necesită existența

unui sistem de baze de date (DBS = Database System), ce reprezintă un set de elemente

interconectate prin intermediul cărora se realizează colectarea, stocarea și procesarea datelor. Din

figura 3.2 se observă faptul că utilizatorul interacționează cu sistemul de baze de date prin

intermediul produselor software instalate, care realizează legătura cu datele, dar și cu alte aplicații

auxiliare.

28

Figura 3.2 Componentele unui sistem de baze de date

Din categoria produselor software, cel mai important este Sistemul de Gestiune a Bazei de

Date(SGBD), ce reprezintă un ansamblu de programe ce oferă o interfață între baza de date și

utilizatori. “Un SGBD este o componentă software a unui sistem de baze de date care

interacționează cu toate celelelte componente, asigurând conectarea și independența dintre

elementele sistemului.” [1]. Astfel, un SGBD are rolul de a asigura: definirea și descrierea structurii

bazei de date, încărcarea și validarea datelor, accesul la date pentru operații de consultare,

interogare sau actualizare, mentenanța bazei de date și protecția bazei de date. Figura 3.3 prezintă

funcțiile unui SGBD (descriere, manipulare, administrare și utilizare), care sunt interconectate și

asigură funcționalitatea întregului sistem. Astfel, funcția de utilizare are rolul de a realiza interfața

cu utilizatorul, funcția de descriere definește structura bazei de date prin limbajul de descriere a

datelor (LDD), funcția de manipulare realizează inserarea și prelucrarea datelor prin limbajul de

maipulare a datelor (LMD), iar funcția de administrare gestionează baza de date.

29

Figura 3.3 Funcțiile unui SGBD

Într-un sistem de calcul, datele sunt stocate atât în memoria internă (temporară), dar mai ales

în memoria externă. Stocarea datelor în memoria externă a fost condiționată de aspecte precum :

accesul rapid și ușor la date, volumul de date tot mai mare, creșterea complexității datelor,

perfecționarea echipamentelor de stocare și nu în ultimul rând lucrul în rețelele

decalculatoare.Stocarea datelor se poate face atât în fișiere, cât și în baze de date (care au evoluat

din fișiere). Baza de date este un ansamblu de colecții de date organizat coerent, structurat astfel

încât redundanța să fie minimă și controlată, iar accesul la date să fie permis mai multor utilizatori

simultan și în timp util. Deși există mai multe generații de baze de date (arborescente, rețea,

relaționale , orientate obiect), cele mai utilizate în practică sunt cele relaționale (aproximativ >75%

din total).

Pentru a înțelege conceputul de bază de date, voi prezenta pe scurt elementele unei baze de

date:

• domeniul de valori desemnează mulțimea valorilor posibile pentru o caracteristică;

• caracteristica reprezintă definirea și descrierea unui anumit aspect dintr-o entitate din lumea

reală;

• familia de caracteristici reprezintă ansamblul proprietăților care se referă la aceeași entitate

din lumea reală;

• colecția de date reprezintă o familie de caracteristici asupra căreia se aplică un predicat care

reprezintă o legătură între colecția curentă de date și o altă colecție.Putem deci spune ca baza de

date este un ansamblu de colecții de date aflate în interdependență împreună cu descrierea datelor.

30

Revenind la modelul relațional, proiectarea unei baze de date presupune definirea entităților și a

legăturilor dintre acestea.Astfel, entitățile vor fi definite sub forma unor tablouri bidimensionale

denumite tabele sau relații.

Conceptele utilizate sunt următoarele:

• domeniul desemnează ansamblul valorilor ce pot fi utilizate;

• tabela sau relatia este un subansamblu al produsului cartezian dintre mai multe domenii,

caracterizat printr-o denumire;

• atributul ilustrează o coloană dintr-o tabelă care are o denumire și care va lua valori dintr-

un

domeniu. Unele atribute pot avea rolul de cheie;

• tuplul (înregistrare/realizare/instanță) este linia dintr-o tabela;

• cheia reprezintă un atribut ori un ansamblu de atribute cu rolul de a identifica un tuplu

dintro

tabelă;

Definirea legăturii dintre entități se face la nivel logic prin construirea de asocieri cu ajutorul

unor atribute de legătură (chei externe).

Ansamblul tabelelor și al legăturilor dintre acestea constituie schema bazei de date.

Un aspect important în realizarea unei baze de date este reprezentat de înlăturarea anomaliilor.

Cea mai utilizată tehnică pentru rezolvarea acestei situații este tehnica normalizării care presupune

ca toate relațiile să respecte cele cinci forme normale.

3.3. Proiectarea practică a bazei de date

Proiectarea unei baze de date reprezintă proiectarea schemei conceptuale (logice) și fizice

a acesteia pentru a răspunde cerințelor uneia sau mai multe aplicații, sau mai exact pentru a

răspunde cerințelor utilizatorilor acesteia. Proiectarea unei baze de date este divizată astfel: studiul

cerințelor aplicației, proiectarea conceptuală, alegerea unui SGBD, proiectarea logică și proiectarea

fizică a bazei de date.

În primul rând trebuie analizate cerințele aplicației și ale situațiilor ce urmează a fi rezolvate

de către aceasta. Deoarece aplicația urmează a fi utilizată de către mai multe persoane în mod

concurențial este nevoie ca aceasta să urmărească o arhitectură client-server, deci și baza de date

utilizată trebuie sa fie adaptabilă acestei situații. Plusuri pentru folosirea acestei tipologii sunt

reprezentate de mărimea securității datelor (care sunt situate pe o mașină–server și pot fi accesate

doar în anumite condiții de către utilizatori), de eliberarea mașinii–client de procesele de calcul dar

31

și de faptul că aplicația și implicit baza de date pot fi accesate de pe orice calculator din rețeaua

locală a companiei (întrucât vorbim despre o aplicație bazată pe web).

Proiectul conceptual se realizează independent de Sistemul de Gestiune a Bazelor de Date ales, și

se reprezintă în general prin modelul Entitate – Asociere (Entity - Relationship) care se

concretizează într-o diagramă Entitate-Asociere.

În proiectarea conceptuală a bazei de date vor fi urmăriți următorii pași:

• Determinarea scopului bazei de date. Baza de date necesară aplicației de management a

inventarierii dispozitivelor medicale păstrează informații despre dispozitivele, categoriile de

dispozitive medicale, producătorii și clienții firmei de comercializare a dispozitivelor

medicale în scopul administrării și gestionării depozitului.

• Împărțirea informațiilor în tabele. Se realizează prin găsirea celor mai importante entități sau

subiecte din descrierea problemei reale. Observăm astfel că principalele entități sunt :

categorie, dispozitive, producători, clienți, utilizatori.

• Transformarea elementelor de informații în coloane. Vom decide ce informații vor fi

stocate în fiecare tabelă. Fiecare element devine un câmp afișat sub forma unei coloane a

tabelului.

• Specificarea cheilor primare. Se alege coloana sau coloanele care vor identifica în mod

unic fiecare înregistrare din tabelă.

În figurile 3.4 – 3.8 se observă faptul că atributele fiecărei entități au fost transformate în

coloane ale tabelelor respective. În plus fiecare tabelă are o cheie primară al cărei rol estem acela de

a identifica fiecare tuplu.

În continuare vor fi prezentate tabelele create.

Figura 3.4 Tabelul Categorie

Figura 3.5 Tabelul Dispozitive

32

Figura 3.6 Tabelul Producători

Figura 3.7 Tabelul Clienți

Figura 3.8 Tabelul Utilizatori

Până acum a fost prezentat modul de design a tabelelor bazei de date.

Proiectarea fizică a bazei de date este reprezentată de alegerea structurilor de acces și

memorare a datelor, astfel încât acestea să fie optime. Se ține cont de timpul de răspuns, utilizarea

spațiului de memorie sau capacitatea tranzacțională. Aceste decizii se pot lua după analiza aplicației

care va utiliza baza de date și mai ales după testarea funcționării acesteia în condițiile dorite (un

anumit număr de utilizatori și un anumit volum de date). În principal, analiza fizică a bazei de date

are ca scop descoperirea atributelor care sunt cel mai frecvent utilizate în interogări sau care sunt

actualizate cel mai des, pentru stabilirea indexurilor secundare ale relațiilor.

Un alt obiectiv care trebuie urmărit în proiectarea bazei de date este reprezentat de către

protecția bazei de date și ne referim la securitatea și integritatea datelor. Securitatea datelor este

33

realizată în primul rând prin autorizarea și controlul accesului la date. Utilizatorii vor fi identificați

și vor avea anumite drepturi în ceea ce privește accesul la baza de date în funcție de calitatea /

funcția pe care o îndeplinesc. Un alt aspect ce ține de securitate este faptul că unele date, cum ar fi

parolele vor fi transmise codificat. Integritatea bazei de date este asigurată prin restricții de

integritate și validări asupra datelor, dar și prin salvarea unor copii de siguranță (backup).

3.4. Proiectarea interfeței de utilizator

Interfața (GUI - Graphical User Interface) este unul dintre cele mai importante elemente ale unei

aplicații deoarece reprezintă partea vizuală cu care interacționează utilizatorul. Scopul interfeței este

acela de a face interacțiunea utilizatorului cât de simplă și eficientă posibil pentru ca acesta sa-și

atingă obiectivele. Acest tip de gândire a interfeței este de cele mai multe ori denumit: user-

centered design și anume aspect centrat pe utilizator și după cum spune denumirea se referă la

faptul că atunci când se proiectează o interfață, persoana care folosește aplicația trebuie să fie cel

mai important element luat în considerare. Procesul de dezvoltare a interfeței trebuie să balanseze

funcționalitatea tehnică și elementele vizuale pentru a crea un sistem care este nu doar operațional

ci și utilizabil și adaptabil la schimbările de care are nevoie utilizatorul. Aspectul referitor la

prezentarea informației este descris mai jos:

• claritate: conținutul informației este redat rapid și exact;

• discriminabilitate: informațiile redate pot fi distinse eficient;

• simplitate: utilizatorii nu sunt supraîncărcați cu informații inutile;

• consistență: un aspect unic, conform cu aștepțările utilizatorilor;

• detectabilitate: atenția utilizatorului este direcționată către informația necesară;

• lizibilitate: informația este ușor de citit;

• înțelegere: informația este ușor de înțeles, neambiguă și ușor recunoscută;

Aspectul aplicației este unul clasic pentru o aplicație desktop, dar nu numai, și este reprezentat de

mai multe ferestre cu funcționalități diferite, cum este prezentat în figurile de mai jos.

În figura 3.9 este reprezentată fereastra de autentificare a aplicației care conține câmpurile pentru

introducerea numelui de utilizator a parolei și butonul de autentificare.

34

Figura 3.9 Fereastra de autentificare a aplicației

În figura 3.10 este reprezentată fereastra de start a aplicației sau pagina Home în care sunt prezente

butoanele de accesare a ferestrelor: Dispozitive, Categorii, Producători, Clienți și

Utilizatori.Fereastra Home reprezintă de fapt meniul aplicației.

Figura 3.10 Meniul aplicației

35

În phpMyAdmin acest meniu este de fapt baza de date cu tabelele respective.Astfel în figura

3.11 este reprezentată baza de date care stă în spatele acestei aplicații.

Figura 3.11 Baza de date creată

În continuare vor fi prezentate toate ferestrele de lucru ale aplicației create.Deci în figura

3.12 este reprezentată fereastra Dispozitive.

Figura 3.12 Fereastra Dispozitive

Fereastra Dispozitive este pagina principală de gestionare și administrare a dispozitivelor din

depozit.

Această opțiune conține tabelul principal de vizualizare a datelor ce conține următoarele coloane:

• Id;

• Denumire;

• Categorie;

• Producător;

• Model;

• Descriere;

• Preț;

• Cantitate;

• Garanție;

36

Coloana Id reprezintă numărul de identificare în cadrul bazei de date;

Coloana Denumire reprezintă câmpul pentru introducerea denumirii dispozitivului;

Coloana Producător este câmpul de vizualizare a prducătorul de la care a fost procurat dispozitivul;

Coloana Model conține denumirea modelului dispozitivului dat;

Coloana Descriere reprezintă câmpul de vizualizare a descrierii despre dispozitiv, de exemplu o

denumire mai lungă sau date tehnice despre acest dispozitiv;

Coloana Preț este prețul cu care a fost procurat dispozitivul;

Coloana Cantitate reprezintă numărul actual de dispozitive care se află în depozit;

Coloana Garanție este câmpul ce conține informația despre cât timp se va afla dispozitivul în

garanția oferită de producător.

Codul sursă pentru tabelul Dispozitive este de fapt o listă definită în clasa Dispozitive.Această clasă

implementeză logica de listare a dispozitivelor firmei:

// lista Dispozitive

public ArrayList<Dispozitive> listaDispozitive(){

ArrayList<Dispozitive> lista_dispozitive = new ArrayList<>();

connection = BD_INFO.getConnection();

ResultSet rs;

PreparedStatement ps;

String query = "SELECT `id`, `denumire`, `categorie`, `producator`, `model`,

`descriere`, `pret`, `cantitate`, `garantie` FROM `dispozitive`";

try {

ps = connection.prepareStatement(query);

rs = ps.executeQuery();

Dispozitive dispozitiv;

while(rs.next()){

dispozitiv = new Dispozitive(rs.getInt("id"),

rs.getString("denumire"),

rs.getString("categorie"),

rs.getString("producator"),

rs.getString("model"),

rs.getString("descriere"),

rs.getString("pret"),

rs.getString("cantitate"),

rs.getString("garantie")

37

);

lista_dispozitive.add(dispozitiv);

}

} catch (SQLException ex) {

Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);

}

return lista_dispozitive;

}

Fereastra Dispozitive conține și câmpurile de introducere a datelor despre:

• Denumirea dispozitivului;

• Categoria din care face parte dispozitivul;

• Producătorul de la care a fost procurat dispozitivul;

• Modelul dispozitivului;

• Descrierea dispozitivului;

• Prețul dispozitivului;

• Cantitatea actuală a dispozitivelor aflate în depozit;

• Garanția dispozitivelor;

De asemenea această fereastră mai conține și funcțiile de:

• Adăugare Dispozitiv;

• Editare Dispozitiv;

• Eliminare Dispozitiv;

• Ștergere Tot;

Funcția Adaugă Dispozitiv permite adăugarea unui dispozitiv nou în baza de date.

Funcția Editare Dispozitiv permite editarea unui dispozitiv existent în baza de date.

Funcția Eliminare Dispozitiv permite eliminarea unui dispozitiv existent în baza de date.

Funcția Șterge Tot permite golirea câmpurilor de introducere a datelor.

Metodele pentru crearea logicii funcțiilor definite mai sus, sunt de asemenea definite în cadrul

clasei Dispozitive.Aceste metode sunt reprezentate în continuare:

38

// adaugare dispozitiv

public static void adaugareDispozitiv(Dispozitive dispozitiv)

{

Connection con = BD_INFO.getConnection();


try {

ps = con.prepareStatement("INSERT INTO `dispozitive`(`denumire`, `categorie`,

`producator`, `model`, `descriere`, `pret`, `cantitate`, `garantie`) VALUES (?,?,?,?,?,?,?,?)");

ps.setString(1, dispozitiv.getDenumire());

ps.setString(2, dispozitiv.getCategorie());

ps.setString(3, dispozitiv.getProducator());

ps.setString(4, dispozitiv.getModel());

ps.setString(5, dispozitiv.getDescriere());

ps.setString(6, dispozitiv.getPret());

ps.setString(7, dispozitiv.getCantitate());

ps.setString(8, dispozitiv.getGarantie());

if(ps.executeUpdate() != 0){

JOptionPane.showMessageDialog(null, "Ați adăugat un dispozitiv nou");

}

else{

JOptionPane.showMessageDialog(null, "Eroare");

}



}

}

//editare Dispozitiv

public static void editareDispozitiv( Dispozitive dispozitiv)

{



try {

ps = con.prepareStatement("UPDATE `dispozitive` SET `denumire`= ?,`categorie`=

?,`producator`= ?,`model`= ?,`descriere`= ?,`pret`= ?,`cantitate`= ?,`garantie`= ? WHERE

`id`= ?");



39







ps.setInt(9, dispozitiv.getId());


JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");

}

else{


}



}

}

// stergere dispozitiv dupa id

public static void stergereDispozitiv(Integer dispozitivId)

{



try {

ps = con.prepareStatement("DELETE FROM `dispozitive` WHERE `id` = ?");

ps.setInt(1, dispozitivId);

// mesaj de confirmare

int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați acest

dispozitiv?","Elimină Dispozitiv", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Dispozitiv eliminat");

}

else{


}

}



}

}

40

Întregul cod al clasei Dispozitive este reprezetat în Anexa 1.

În baza de date datele introduse sunt reprezentate la fel sub formă de tabel.

În figura 3.13 este reprezentat tabelul dispozitive în phpMyAdmin.

Figura 3.13 Tabelul dispozitive în baza de date a aplicației

În figura 3.14 este reprezentată fereastra Categorii.

Figura 3.14 Fereastra Categorii

Fereastra Categorii este pagina principală de gestionare și administrare a categoriilor de dispozitive

medicale.


• Id;

• Denumire;


Coloana Denumire reprezintă câmpul pentru introducerea denumirii categoriei de dispozitive

medicale.

Codul sursă pentru tabelul Categorii este de fapt o listă definită în clasa Categorii.Această

clasă implementeză logica de listare a categoriilor de dispozitive medicale:

41

// lista Categorii

public ArrayList<Categorii> listaCategorii(){

ArrayList<Categorii> lista_categorii = new ArrayList<>();


ResultSet rs;


String query = "SELECT `id`, `denumire` FROM `categorie`";

try {



Categorii categorie;

while(rs.next()){

categorie = new Categorii(rs.getInt("id"),

rs.getString("denumire")

);

lista_categorii.add(categorie);

}


Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);

}

return lista_categorii;

}

Acestă fereastră conține și câmpurile de introducere a datelor despre:

• Denumirea categoriei;


• Adăugare Categorie;

• Editare Categorie;

• Eliminare Categorie;

• Ștergere Tot;

Funcția Adaugă Categorie permite adăugarea unei categorii nou în baza de date.

Funcția Editare Categorie permite editarea unei categorii existente în baza de date.

Funcția Eliminare Categorie permite eliminarea unei categorii existent în baza de date.


42

Metodele pentru crearea logicii funcțiilor definite mai sus, sunt de asemenea definite în

cadrul clasei Categorii.Aceste metode sunt reprezentate în continuare:

// adaugare Categorie

public static void adaugareCategorie(Categorii categorie)

{



try {

ps = con.prepareStatement("INSERT INTO `categorie`(`denumire`) VALUES

(?)");

ps.setString(1, categorie.getDenumire());


JOptionPane.showMessageDialog(null, "Ați adăugat o categorie nouă");

}

else{


}



}

}

// editare categorie

public static void editareCategorie(Categorii categorie)

{



try {

ps = con.prepareStatement("UPDATE `categorie` SET `denumire`= ? WHERE

`id`= ?");


ps.setInt(2, categorie.getId());



}

43

else{


}



}

}

// stergere categorie dupa id

public static void stergereCategorie(Integer categorieId)

{



try {

ps = con.prepareStatement("DELETE FROM `categorie` WHERE `id` = ?");

ps.setInt(1, categorieId);


int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați

această categorie?","Elimină Categorie", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Categorie eliminată");

}

else{


}

}



}

}

Întregul cod al clasei Categorii este reprezetat în Anexa 1.


În figura 3.15 este reprezentat tabelul categorie în phpMyAdmin.

44

Figura 3.15 Tabelul categorie în baza de date a aplicației

În figura 3.16 este reprezentată fereastra Producători.

Figura 3.16 Fereastra Producători

Fereastra Producători este pagina principală de gestionare și administrare a producătorilor cu care

cooperează compania.


• Id;

• Denumire;

• Persoană Contact;

• Adresă;

• Telefon;

• Email;

• Site;

• Autorizație;


Coloana Denumire reprezintă câmpul pentru introducerea denumirii producătorului;

45

Coloana Persoană Contact este câmpul de vizualizare a persoanei de contact cu care duce convorbiri

despre cumpărarea dispozitivului managerul de vânzări din companie;

Coloana Adresă conține denumirea adresei producătorului;

Coloana Telefon reprezintă câmpul de vizualizare a telefonului de contact a producătorului;

Coloana Email este poșta electronică prin care poate fi contactat producătorul;

Coloana Site reprezintă site-ul oficial al producătorului de dispozitive medicale;

Coloana Autorizație este câmpul ce conține informația de confirmare a autorizației de la producător.

Codul sursă pentru tabelul Producători este de fapt o listă definită în clasa

Producatori.Această clasă implementeză logica de listare a producătorilor cu care cooperează

compania:

// lista Producatori

public ArrayList<Producatori> listaProducatori(){

ArrayList<Producatori> lista_producatori = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `denumire`, `persoana_contact`, àdresa`, `tel`,

èmail`, `site`, àutorizatie` FROM `producatori`";

try {



Producatori producator;

while(rs.next()){

producator = new Producatori(rs.getInt("id"),


rs.getString("persoana_contact"),

rs.getString("adresa"),

rs.getString("tel"),

rs.getString("email"),

rs.getString("site"),

rs.getString("autorizatie")

);

lista_producatori.add(producator);

}


46

Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);

}

return lista_producatori;

}


• Denumirea producătorului;

• De contact cu care duce convorbiri managerul de vânzări;

• Adresa producătorului;

• Telefonul producătorului;

• Email-ul producătorului;

• Site-ul producătorului;

• Autorizația producătorului;


• Adăugare Producător;

• Editare Producător;

• Eliminare Producător;

• Ștergere Tot;

Funcția Adaugă Producător permite adăugarea unui producător nou în baza de date.

Funcția Editare Producător permite editarea unui producător existent în baza de date.

Funcția Eliminare Producător permite eliminarea unui producător existent în baza de date.



cadrul clasei Producatori.Aceste metode sunt reprezentate în continuare:

// adaugare producator

public static void adaugareProducator(Producatori producator)

{



try {

ps = con.prepareStatement("INSERT INTO `producatori`(`denumire`,

`persoana_contact`, àdresa`, `tel`, èmail`, `site`, àutorizatie`) VALUES (?,?,?,?,?,?,?)");

ps.setString(1, producator.getDenumire());

ps.setString(2, producator.getPersoana_Contact());

ps.setString(3, producator.getAdresa());

ps.setString(4, producator.getTel());

47

ps.setString(5, producator.getEmail());

ps.setString(6, producator.getSite());

ps.setString(7, producator.getAutorizatie());


JOptionPane.showMessageDialog(null, "Ați adăugat un producător nou");

}

else{


}



}

}

// editare Denumire

public static void editareProducator(Producatori producator)

{



try {

ps = con.prepareStatement("UPDATE `producatori` SET `denumire`=

?,`persoana_contact`= ?,àdresa`= ?,`tel`= ?,èmail`= ?,`site`= ?,àutorizatie`= ? WHERE ìd`=

?");








ps.setInt(8, producator.getId());



}

else{


}


48


}

}

// stergere producator dupa id

public static void stergereProducator(Integer producatorId)

{



try {

ps = con.prepareStatement("DELETE FROM `producatori` WHERE `id` =

?");

ps.setInt(1, producatorId);


int DaOrNu = JOptionPane.showConfirmDialog(null,"Dooriți sa eliminați acest

producător?","Elimină Producător", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Producător eliminat");

}

else{


}

}



}

}

Întregul cod al clasei Producatori este reprezetat în Anexa 1.


În figura 3.17 este reprezentat tabelul categorie în phpMyAdmin.

Figura 3.17 Tabelul producatori în baza de date a aplicației

49

În figura 3.18 este reprezentată fereastra Clienți.

Figura 3.18 Fereastra Clienți

Fereastra Clienți este pagina principală de gestionare și administrare a clienților cu care are

contracte compania.


• Id;

• Nume;

• Director;

• Adresă;

• Telefon;

• Email;

• IBAN;

• IDNO;

• Bancă;


Coloana Nume reprezintă câmpul pentru introducerea denumirii clientului;

Coloana Director este câmpul de vizualizare a directorului de la spitalul cu care are contract

compania;

Coloana Adresă conține denumirea adresei clientului;

Coloana Telefon reprezintă câmpul de vizualizare a telefonului de contact a clientului;

Coloana Email este poșta electronică prin care poate fi contactat clientului;

50

Coloana IBAN reprezintă contul de decontare al clientului;

Coloana IDNO este câmpul ce conține informația despre codul fiscal al clientului.

Coloana Bancă reprezintă numele băncii prin care livrează banii clientul;

Codul sursă pentru tabelul Clienți este de fapt o listă definită în clasa Clienti.Această clasă

implementeză logica de listare a clienților firmei:

// lista Clienti

public ArrayList<Clienti> listaClienti(){

ArrayList<Clienti> lista_clienti = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `nume`, `persoana_contact`, àdresa`, `tel`,

èmail`, ìban`, ìdno`, `banca` FROM `clienti`";

try {



Clienti client;

while(rs.next()){

client = new Clienti(rs.getInt("id"),

rs.getString("nume"),





rs.getString("iban"),

rs.getString("idno"),

rs.getString("banca")

);

lista_clienti.add(client);

}


Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);

}

return lista_clienti;

}


• Numele clientului;

• Persoană de contact- directorul spitalului;

51

• Adresa clientului;

• Telefonul clientului;

• Email-ul clientului;

• IBAN-ul clientului;

• IDNO-ul clientului;

• Banca clientului;


• Adăugare Client;

• Editare Client;

• Eliminare Client;

• Ștergere Tot;

Funcția Adaugă Client permite adăugarea unui client nou în baza de date.

Funcția Editare Client permite editarea unui client existent în baza de date.

Funcția Eliminare Client permite eliminarea unui client existent în baza de date.



cadrul clasei Clienti.Aceste metode sunt reprezentate în continuare:

// adaugare client

public static void adaugareClient(Clienti client)

{



try {

ps = con.prepareStatement("INSERT INTO `clienti`(`nume`,

`persoana_contact`, àdresa`, `tel`, èmail`, ìban`, ìdno`, `banca`) VALUES

(?,?,?,?,?,?,?,?)");

ps.setString(1, client.getNume());

ps.setString(2, client.getPersoana_Contact());

ps.setString(3, client.getAdresa());

ps.setString(4, client.getTel());

ps.setString(5, client.getEmail());

ps.setString(6, client.getIban());

ps.setString(7, client.getIdno());

ps.setString(8, client.getBanca());


JOptionPane.showMessageDialog(null, "Ați adăugat un client nou");

52

}

else{


}



}

}

// editare client

public static void editareClient(Clienti client)

{



try {

ps = con.prepareStatement("UPDATE `clienti` SET `nume`=

?,`persoana_contact`= ?,àdresa`= ?,`tel`= ?,èmail`= ?,ìban`= ?,ìdno`= ?,`banca`= ?

WHERE ìd`= ?");









ps.setInt(9, client.getId());



}

else{


}



}

}

// stergere client dupa id

public static void stergereClient(Integer clientId)

53

{



try {

ps = con.prepareStatement("DELETE FROM `clienti` WHERE `id` = ?");

ps.setInt(1, clientId);



client?","Elimină Client", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Client șters");

}

else{


}

}



}

}

Întregul cod al clasei Clienti este reprezetat în Anexa 1.


În figura 3.19 este reprezentat tabelul clienti în phpMyAdmin.

Figura 3.19 Tabelul clienti în baza de date a aplicației

54

3.5. Utilizarea aplicației

Aplicația este intuitivă și ușor de utilizat de orice persoană, chiar și neinițiată în lucrul cu

calculatorul sau în domeniul getsionării depozitului. Primul pas care trebuie făcut pentru a putea

folosi aplicația este autentificarea, prin introducerea numelui de utilizator și a parolei setate, ca în

figura 3.20.

Figura 3.20 Autentificarea aplicației

După autentificarea în aplicație, utilizatorul are acces la zona de lucru ce va fi prezentată în ceea ce

urmează. Implementarea paginii principale este prezentată în Anexa 1.

În primul rând, zona din partea de sus a ecranului conține numele aplicației, iar

în partea de jos este reprezentat footer-ul aplicației cu dreptul de autor rezervat după cum este

prezentat în figura 3.21 și 3.22:

Figura 3.21 Header-ul aplicației

Figura 3.22 Footer-ul aplicației

55

Administrarea utilizatorilor se face într-o fereastră modală, care nu permite accesul utilizatorilor la

ea, ci doar a administratorilor.Astfel, administratorul poate vizualiza datele despre utilizatori.

În figura 3.23 este reprezentată fereastra UTILIZATORI.

Figura 3.23 Fereastra UTILIZATORI

Fereastra UTILIZATORI este pagina principală de gestionare și administrare a utilizatorilor

aplicației.


• Id;

• Nume Utilizator;

• Parolă;

• Nume;

• Telefon;

• Email;


Coloana Nume Utilizator reprezintă câmpul pentru vizualizarea numelui de utilizator prin care se va

autentifica utilizatorul în aplicație;

Coloana Parolă este câmpul de vizualizare a parolei utilizatorului;

Coloana Nume conține numele și prenumele utilizatorului;

Coloana Telefon reprezintă câmpul de vizualizare a telefonului de contact a utilizatorului;

Coloana Email este poșta electronică a utilizatorului;

Codul sursă pentru tabelul Utilizatori este de fapt o listă definită în clasa Utilizatori.Această

clasă implementeză logica de listare a utilizatorilor aplicației:

56

// lista utilizatori

public ArrayList<Utilizatori> ListaUtilizatori(){

ArrayList<Utilizatori>lista_utilizatori = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `nume_utilizator`, `parola`, `tip_utilizator`, `nume`,

`tel`, èmail` FROM ùtilizatori` WHERE `tip_utilizator` = 'user'";

try {



Utilizatori utilizator;

while(rs.next()){

utilizator = new Utilizatori(rs.getInt("id"),

rs.getString("nume_utilizator"),

rs.getString("parola"),

rs.getString("tip_utilizator"),



rs.getString("email")

);

lista_utilizatori.add(utilizator);

}


Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);

}

return lista_utilizatori;

}

57


• Numele de utilizator prin care utilizatorul se va autentifica în aplicație;

• Parola prin care utilizatorul se va autentifica în aplicație ;

• Numele și prenumele utilizatorului;

• Telefonul utilizatorului;

• Email-ul utilizatorului;


• Adăugare Utilizator;

• Editare Utilizator;

• Eliminare Utilizator;

• Ștergere Utilizator;

Funcția Adaugă Utilizator permite adăugarea unui utilizator nou în baza de date.

Funcția Editare Utilizator permite editarea unui client utilizator în baza de date.

Funcția Eliminare Utilizator permite eliminarea unui utilizator existent în baza de date.



cadrul clasei Utilizatori.Aceste metode sunt reprezentate în continuare:

// adaugare utilizator

public static void adaugareUtilizator(Utilizatori utilizator)

{



try {

ps = con.prepareStatement("INSERT INTO `utilizatori`(`nume_utilizator`,

`parola`, `tip_utilizator`, `nume`, `tel`, `email`) VALUES (?,?,?,?,?,?)");

ps.setString(1, utilizator.getNume_Utilizator());

ps.setString(2, utilizator.getParola());

ps.setString(3, "user");// administratorul va adauga un utilizator nou

ps.setString(4, utilizator.getNume());

ps.setString(5, utilizator.getTel());

ps.setString(6, utilizator.getEmail());


JOptionPane.showMessageDialog(null, "Ați adăugat un utilizator nou");

}

else{


58

}



}

}

// editare utilizator

public static void editareUtilizator(Utilizatori utilizator)

{



try {

ps = con.prepareStatement("UPDATE ùtilizatori` SET

`nume_utilizator`=?,`parola`=?,`nume`=?,`tel`=?,èmail`=? WHERE ìd`=?");






ps.setInt(6, utilizator.getId());



}

else{


}



}

}

// stergere utilizator

public static void stergereUtilizator(Integer utilizatorId)

{



try {

ps = con.prepareStatement("DELETE FROM ùtilizatori` WHERE ìd` = ?");

59

ps.setInt(1, utilizatorId);


int YesOrNo = JOptionPane.showConfirmDialog(null,"Doriți să ștergeți acest

utilizator?","Șterge Utilizator", JOptionPane.YES_NO_OPTION);

if(YesOrNo == 0){


JOptionPane.showMessageDialog(null, "Utilizator Șters");

}

else{


}

}



}

}

Întregul cod al clasei Utilizatori este reprezentat în Anexa 1.


În figura 3.24 este reprezentat tabelul utilizatori în phpMyAdmin.

Figura 3.24 Tabelul utilizatori în baza de date a aplicației

Restul paginilor au fost explicate în subcabitolul 3.4.

60

CONCLUZII

În concluzie, pot spune că tema aleasă a fost una interesantă și atractivă din punct de vedere

al bioingineriei, dar mai ales din punct de vedere informatic. În ceea ce privește domeniul

bioingineriei, tema a fost interesantă deoarece a presupus cercetarea unui domeniu dinamic ce

trebuie să fie optimizat. Din punct de vedere informatic, atractivitatea temei s-a manifestat prin

găsirea unei soluții de adminstrare a domeniului studiat.

Cercetarea a presupus o documentare riguroasă în domeniul bazelor de date și al dezvoltării

aplicațiilor desktop și s-a finalizat cu realizarea unei aplicații desktop ce utilizează o bază de date și

este aplicabilă oricărei firme de comercializare a dispozitivelor medicale.

Aplicația creată oferă posibilitatea administrării acestei activități prin ținerea unei evidențe

stricte a categoriilor de dispozitive medicale, a dispozitivelor medicale ce se află în stoc, a

producătorilor cu care cooperează compania și clienților la care furnizează dispositive compania.

Această aplicație reprezintă o soluţie inteligentă de inventariere a dispozitivelor medicale în

cadrul companiilor de vânzări a acestor produse.

Acest sistem asigură o monitorizare și o gestionare eficientă a stocurilor unei companii

indiferent de numarul de produse, furnizori și clienți.

Astfel aplicația oferă posibilitatea de gestionare a depozitului.

Implementarea acestui sistem de inventariere în companiile de comercializare a dispozitivelor

medicale ar însemna reducerea dificultăților asociate inventarelor. Unele dintre avantajele asociate

cu sistemul automatizat includ:

• Managementul stocurilor mărește profitabilitatea;

• Prognoza, controlul și gestionarea inventarului crește productivitatea și vânzările,

reducând în același timp costurile, ducând la o mai mare profitabilitate;

• Îmbunătățirile de timp și economiile de timp, pe lângă reducerea greșelilor costisitoare;

• Acces rapid la baza de date și un set de instrumente pentru gestionarea activităților de

adăugare, editare, eliminare a dispozitivelor din stoc;

• Managementul stocurilor îmbunătățește luarea deciziilor;

• Managementul stocurilor mărește satisfacția clienților;

61

Soluția informatică realizată poate fi extinsă, iar una dintre primele idei de extindere este

implementarea unui buton de căutare care să permită căutarea datelor în baza de date în toate

ferestrele și o altă fereastră care să permită gestionarea comezilor companiei.Pot fi extinse și

facilitățile deja existente, prin adăugarea unui număr de situații de ieșire precum grafice, rapoarte,

etc.

62

BIBLIOGRAFIE

Manuale:

1. Michael Kofler – “The Definitive Guide to MySQL 5”, Apress, 2005

2. Ion Lungu, Manole Velicanu, Iuliana Botha –“Database Systems – Present and Future”

3. Eugen Petac, Tudor Udrescu - “Programarea calculatoarelor. Aplicatii Java”

4. Stefan Tanasa, Cristian Olaru, Stefan Andrei - “Java de la 0 la expert”

5. Horia Georgescu - “Introducere in universul JAVA”

6. G. Stoian, C.-I. Popirlan - “Tehnologii java pentru dezvoltarea aplicațiilor. Editura

Universitaria, Craiova, 2009”

7. Metodologia de inventariere in cadrul IMSP

Link-uri:

8. http://java.sun.com/javase/downloads/index.jsp

9. http://java.sun.com/j2se/1.4.2/docs/api/java/awt/package-summary.html

10. http://java.sun.com/docs/books/tutorial/

11. http://www.apl.jhu.edu/~hall/java/

12. https://netbeans.apache.org/download/index.html

13. https://dev.mysql.com/downloads/connector/net/6.10.html

14. http://www.wampserver.com/en/download-wampserver-64bits/

15. http://www.amed.md/ro/med-oborudovanie

16. http://lex.justice.md/viewdoc.php?action=view&view=doc&id=344071&lang=1

17. http://lex.justice.md/md/344361/

https://www.librarie.net/cautare-rezultate.php?au=18941





http://java.sun.com/javase/downloads/index.jsp

http://java.sun.com/j2se/1.4.2/docs/api/java/awt/package-summary.html

http://java.sun.com/docs/books/tutorial/

http://www.apl.jhu.edu/~hall/java/

https://netbeans.apache.org/download/index.html

https://dev.mysql.com/downloads/connector/net/6.10.html

http://www.wampserver.com/en/download-wampserver-64bits/

http://www.amed.md/ro/med-oborudovanie

http://lex.justice.md/viewdoc.php?action=view&view=doc&id=344071&lang=1

http://lex.justice.md/md/344361/

63

ANEXE

Anexa 1

Codul Sursă

Folder Clase

Clasa Funții

package clase;

import java.awt.Image;

import java.io.File;

import javax.swing.ImageIcon;

import javax.swing.JFileChooser;

import javax.swing.JLabel;

import javax.swing.filechooser.FileNameExtensionFilter;

public class Functii {

public ImageIcon resizePic(String picPath,byte[] BLOBpic, int wdth, int hgt){

ImageIcon myImg;

if(picPath != null){

myImg = new ImageIcon(picPath);

}else{

myImg = new ImageIcon(BLOBpic);

}

Image img = myImg.getImage().getScaledInstance(wdth, hgt, Image.SCALE_SMOOTH);

ImageIcon myPicture = new ImageIcon(img);

return myPicture;

}

public String browseImage(JLabel lbl)

{

String path = null;

JFileChooser filec = new JFileChooser();

filec.setCurrentDirectory(new File(System.getProperty("user.home")));

// file extension

FileNameExtensionFilter fileFilter = new

FileNameExtensionFilter("*.Images","jpg","png","gif");

filec.addChoosableFileFilter(fileFilter);

int fileState = filec.showSaveDialog(null);

// if the user select a file

64

if(fileState == JFileChooser.APPROVE_OPTION){

File selectedFile = filec.getSelectedFile();

path = selectedFile.getAbsolutePath();

// imagePth = path;

// display the image in the jlabel using resize image

lbl.setIcon(resizePic(path,null, lbl.getWidth(),lbl.getHeight()));

//jLabelPic.setIcon(new ImageIcon(path));

}

// if the user cancel

else if(fileState == JFileChooser.CANCEL_OPTION){

System.out.println("No Image Selected");

}

return path;

}

}

Folder clase.conectare_bd

Clasa BD_INFO

package clase.conectare_bd;

import java.sql.Connection;

import java.sql.DriverManager;

/**

* @author Macari Mihaela

*/

public class BD_INFO {

private static String dbname = "bd_inventar";

private static String username = "root";

private static String password = "";

static Connection con=null;

public static Connection getConnection()

{

if (con != null) return con;

// get database, user, password from settings file

return getConnection(dbname, username, password);

}

private static Connection getConnection(String db_name,String user_name,String password)

{

try

65

{

Class.forName("com.mysql.jdbc.Driver");

con=DriverManager.getConnection("jdbc:mysql://localhost/"+db_name+"?user="+user_name+"&p

assword="+password);

System.out.println("connected");

}

catch(Exception e)

{

e.printStackTrace();

}

return con;

}

}

Folder clase.model

Clasa Categorii

package clase.model;

import clase.conectare_bd.BD_INFO;


import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.JOptionPane;

/**

*

* @author Mihaela Macari

*/

public class Categorii {

Connection connection;

private Integer id;

private String denumire;

public Categorii(){}

public Categorii(Integer ID, String DENUMIRE)

{

this.id = ID;

this.denumire = DENUMIRE;

66

}

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getDenumire() {

return denumire;

}

public void setDenumire(String denumire) {

this.denumire = denumire;

}

// lista Categorii

public ArrayList<Categorii> listaCategorii(){

ArrayList<Categorii> lista_categorii = new ArrayList<>();


ResultSet rs;


String query = "SELECT `id`, `denumire` FROM `categorie`";

try {



Categorii categorie;

while(rs.next()){

categorie = new Categorii(rs.getInt("id"),

rs.getString("denumire")

);

lista_categorii.add(categorie);

}



}

67

return lista_categorii;

}

// adaugare Categorie

public static void adaugareCategorie(Categorii categorie)

{



try {

ps = con.prepareStatement("INSERT INTO `categorie`(`denumire`) VALUES (?)");



JOptionPane.showMessageDialog(null, "Ați adăugat o categorie nouă");

}

else{


}



}

}

// editare categorie

public static void editareCategorie(Categorii categorie)

{



try {

ps = con.prepareStatement("UPDATE `categorie` SET `denumire`= ? WHERE `id`= ?");


ps.setInt(2, categorie.getId());



}

else{

68


}



}

}

// stergere categorie dupa id

public static void stergereCategorie(Integer categorieId)

{



try {

ps = con.prepareStatement("DELETE FROM `categorie` WHERE `id` = ?");

ps.setInt(1, categorieId);


int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați această

categorie?","Elimină Categorie", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Categorie eliminată");

}

else{


}

}



}

}

}

Clasa Clienți





69



import java.sql.Statement;


import java.util.HashMap;




/**

*


*/

public class Clienti {


private Integer id;

private String nume;

private String persoana_contact;

private String adresa;

private String tel;

private String email;

private String iban;

private String idno;

private String banca;

public Clienti(){}

public Clienti(Integer ID, String NUME, String PERSOANA_CONTACT, String ADRESA,

String TEL, String EMAIL, String IBAN, String IDNO, String BANCA)

{

this.id = ID;

this.nume = NUME;

this.persoana_contact = PERSOANA_CONTACT;

this.adresa = ADRESA;

this.tel = TEL;

this.email = EMAIL;

this.iban = IBAN;

this.idno = IDNO;

this.banca = BANCA;

}


return id;

}


70

this.id = id;

}

public String getNume() {

return nume;

}

public void setNume(String nume) {

this.nume = nume;

}

public String getPersoana_Contact() {

return persoana_contact;

}

public void setPersoana_Contact(String persoana_contact) {

this.persoana_contact = persoana_contact;

}

public String getAdresa() {

return adresa;

}

public void setAdresa(String adresa) {

this.adresa = adresa;

}

public String getTel() {

return tel;

}

public void setTel(String tel) {

this.tel = tel;

}

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

public String getIban() {

return iban;

}

public void setIban(String iban) {

this.iban = iban;

71

}

public String getIdno() {

return idno;

}

public void setIdno(String idno) {

this.idno = idno;

}

public String getBanca() {

return banca;

}

public void setBanca(String banca) {

this.banca = banca;

}

// lista Clienti

public ArrayList<Clienti> listaClienti(){

ArrayList<Clienti> lista_clienti = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `nume`, `persoana_contact`, àdresa`, `tel`, èmail`, ìban`,

ìdno`, `banca` FROM `clienti`";

try {



Clienti client;

while(rs.next()){

client = new Clienti(rs.getInt("id"),






rs.getString("iban"),

rs.getString("idno"),

rs.getString("banca")

72

);

lista_clienti.add(client);

}



}

return lista_clienti;

}

// adaugare client

public static void adaugareClient(Clienti client)

{



try {

ps = con.prepareStatement("INSERT INTO `clienti`(`nume`, `persoana_contact`, àdresa`,

`tel`, èmail`, ìban`, ìdno`, `banca`) VALUES (?,?,?,?,?,?,?,?)");










JOptionPane.showMessageDialog(null, "Ați adăugat un client nou");

}

else{


}



}

}

// editare client

public static void editareClient(Clienti client)

{

73



try {

ps = con.prepareStatement("UPDATE `clienti` SET

`nume`= ?,`persoana_contact`= ?,àdresa`= ?,`tel`= ?,èmail`= ?,ìban`= ?,ìdno`= ?,`banca`= ?

WHERE ìd`= ?");









ps.setInt(9, client.getId());



}

else{


}



}

}

// stergere client dupa id

public static void stergereClient(Integer clientId)

{



try {

ps = con.prepareStatement("DELETE FROM `clienti` WHERE ìd` = ?");

ps.setInt(1, clientId);



client?","Elimină Client", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){

74


JOptionPane.showMessageDialog(null, "Client șters");

}

else{


}

}



}

}

}

Clasa Dispozitive











/**

*


*/

public class Dispozitive {


private Integer id;

private String denumire ;

private String categorie;

private String producator;

private String model ;

private String descriere ;

private String pret ;

private String cantitate ;

private String garantie ;

public Dispozitive(){}

75

public Dispozitive(Integer ID, String DENUMIRE, String CATEGORIE, String PRODUCATOR,

String MODEL, String DESCRIERE, String PRET, String CANTITATE,String GARANTIE)

{

this.id = ID;


this.categorie = CATEGORIE;

this.producator = PRODUCATOR;

this.model = MODEL;

this.descriere = DESCRIERE;

this.pret = PRET;

this.cantitate = CANTITATE;

this.garantie = GARANTIE;

}


return id;

}


this.id = id;

}


return denumire;

}



}

public String getCategorie() {

return categorie;

}

public void setCategorie(String categorie) {

this.categorie = categorie;

}

public String getProducator() {

return producator;

}

public void setProducator(String producator) {

this.producator = producator;

}

public String getModel() {

return model;

}

76

public void setModel(String model) {

this.model = model;

}

public String getDescriere() {

return descriere;

}

public void setDescriere(String descriere) {

this.descriere = descriere;

}

public String getPret() {

return pret;

}

public void setPret(String pret) {

this.pret = pret;

}

public String getCantitate() {

return cantitate;

}

public void setCantitate(String cantitate) {

this.cantitate = cantitate;

}

public String getGarantie() {

return garantie;

}

public void setGarantie(String garantie) {

this.garantie = garantie;

}

// lista Dispozitive

public ArrayList<Dispozitive> listaDispozitive(){

ArrayList<Dispozitive> lista_dispozitive = new ArrayList<>();


ResultSet rs;


77

String query = "SELECT `id`, `denumire`, `categorie`, `producator`, `model`, `descriere`,

`pret`, `cantitate`, `garantie` FROM `dispozitive`";

try {



Dispozitive dispozitiv;

while(rs.next()){

dispozitiv = new Dispozitive(rs.getInt("id"),


rs.getString("categorie"),

rs.getString("producator"),

rs.getString("model"),

rs.getString("descriere"),

rs.getString("pret"),

rs.getString("cantitate"),

rs.getString("garantie")

);

lista_dispozitive.add(dispozitiv);

}



}

return lista_dispozitive;

}

// adaugare dispozitiv

public static void adaugareDispozitiv(Dispozitive dispozitiv)

{



try {

ps = con.prepareStatement("INSERT INTO `dispozitive`(`denumire`, `categorie`,

`producator`, `model`, `descriere`, `pret`, `cantitate`, `garantie`) VALUES (?,?,?,?,?,?,?,?)");








78



JOptionPane.showMessageDialog(null, "Ați adăugat un dispozitiv nou");

}

else{


}



}

}

//editare Dispozitiv

public static void editareDispozitiv( Dispozitive dispozitiv)

{



try {

ps = con.prepareStatement("UPDATE `dispozitive` SET

`denumire`= ?,`categorie`= ?,`producator`= ?,`model`= ?,`descriere`= ?,`pret`= ?,`cantitate`= ?,`gara

ntie`= ? WHERE `id`= ?");









ps.setInt(9, dispozitiv.getId());



}

else{


}



79

}

}

// stergere dispozitiv dupa id

public static void stergereDispozitiv(Integer dispozitivId)

{



try {

ps = con.prepareStatement("DELETE FROM `dispozitive` WHERE `id` = ?");

ps.setInt(1, dispozitivId);



dispozitiv?","Elimină Dispozitiv", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Dispozitiv eliminat");

}

else{


}

}



}

}

}

Clasa Model_Tabel


import javax.swing.Icon;

import javax.swing.table.AbstractTableModel;

// creare tabel pentru vizualizarea datelor

public class Model_Tabel extends AbstractTableModel {

80

private String[] columns;

private Object[][] rows;

public Model_Tabel(){}

public Model_Tabel(Object[][] data, String[] columnsName){

this.columns = columnsName;

this.rows = data;

}

@Override

public Class getColumnClass(int col)

{

// the index of the image column is 6

if(col == 6){ return Icon.class; }

else{

return getValueAt(0, col).getClass();

}

}

@Override

public int getRowCount() {

return this.rows.length;

}

@Override

public int getColumnCount() {

return this.columns.length;

}

@Override

public Object getValueAt(int rowIndex, int columnIndex) {

return this.rows[rowIndex][columnIndex];

}

@Override

public String getColumnName(int col){

return this.columns[col];

}

}

81

Clasa Producători







import java.sql.Statement;


import java.util.HashMap;




/**

*


*/

public class Producatori {


private Integer id;

private String denumire;

private String persoana_contact;

private String adresa;

private String tel;


private String site;

private String autorizatie;

public Producatori(){}

public Producatori(Integer ID, String DENUMIRE, String PERSOANA_CONTACT, String

ADRESA, String TEL, String EMAIL, String SITE, String AUTORIZATIE)

{

this.id = ID;


this.persoana_contact = PERSOANA_CONTACT;

this.adresa = ADRESA;

this.tel = TEL;

this.email = EMAIL;

this.site = SITE;

this.autorizatie = AUTORIZATIE;

}


82

return id;

}


this.id = id;

}


return denumire;

}



}

public String getPersoana_Contact() {

return persoana_contact;

}

public void setPersoana_Contact(String persoana_contact) {

this.persoana_contact = persoana_contact;

}

public String getAdresa() {

return adresa;

}

public void setAdresa(String adresa) {

this.adresa = adresa;

}


return tel;

}


this.tel = tel;

}


return email;

}


this.email = email;

}

public String getSite() {

return site;

83

}

public void setSite(String site) {

this.site = site;

}

public String getAutorizatie() {

return autorizatie;

}

public void setAutorizatie(String autorizatie) {

this.autorizatie = autorizatie;

}

// lista Producatori

public ArrayList<Producatori> listaProducatori(){

ArrayList<Producatori> lista_producatori = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `denumire`, `persoana_contact`, àdresa`, `tel`, èmail`,

`site`, àutorizatie` FROM `producatori`";

try {



Producatori producator;

while(rs.next()){

producator = new Producatori(rs.getInt("id"),






rs.getString("site"),

rs.getString("autorizatie")

);

lista_producatori.add(producator);

}


84


}

return lista_producatori;

}

// adaugare producator

public static void adaugareProducator(Producatori producator)

{



try {

ps = con.prepareStatement("INSERT INTO `producatori`(`denumire`, `persoana_contact`,

àdresa`, `tel`, èmail`, `site`, àutorizatie`) VALUES (?,?,?,?,?,?,?)");









JOptionPane.showMessageDialog(null, "Ați adăugat un producător nou");

}

else{


}



}

}

// editare Denumire

public static void editareProducator(Producatori producator)

{



try {

ps = con.prepareStatement("UPDATE `producatori` SET

`denumire`= ?,`persoana_contact`= ?,àdresa`= ?,`tel`= ?,èmail`= ?,`site`= ?,àutorizatie`= ?

WHERE ìd`= ?");

85








ps.setInt(8, producator.getId());



}

else{


}



}

}

// stergere producator dupa id

public static void stergereProducator(Integer producatorId)

{



try {

ps = con.prepareStatement("DELETE FROM `producatori` WHERE `id` = ?");

ps.setInt(1, producatorId);


int DaOrNu = JOptionPane.showConfirmDialog(null,"Dooriți sa eliminați acest

producător?","Elimină Producător", JOptionPane.YES_NO_OPTION);

if(DaOrNu == 0){


JOptionPane.showMessageDialog(null, "Producător eliminat");

}

else{


}

}

86



}

}

}

Clasa Utilizatori











public class Utilizatori {


private Integer id;

private String nume_utilizator;

private String parola;

private String tip_utilizator;

private String nume;

private String tel;


public Utilizatori(){}

public Utilizatori(Integer ID, String NUME_UTILIZATOR, String PAROLA, String

TIP_UTILIZATOR, String NUME, String TEL, String EMAIL)

{

this.id = ID;

this.nume_utilizator = NUME_UTILIZATOR;

this.parola = PAROLA;

this.tip_utilizator = TIP_UTILIZATOR;

this.nume = NUME;

this.tel = TEL;

this.email = EMAIL;

}

87


return id;

}


this.id = id;

}

public String getNume_Utilizator() {

return nume_utilizator;

}

public void setNume_Utilizator(String nume_utilizator) {

this.nume_utilizator = nume_utilizator;

}

public String getParola() {

return parola;

}

public void setParola(String parola) {

this.parola = parola;

}

public String getTip_Utilizator() {

return tip_utilizator;

}

public void setTip_Utilizator(String tip_utilizator) {

this.tip_utilizator = tip_utilizator;

}

public String getNume() {

return nume;

}

public void setNume(String nume) {

this.nume = nume;

}


return tel;

}


this.tel = tel;

}

88


return email;

}


this.email = email;

}

// lista utilizatori

public ArrayList<Utilizatori> ListaUtilizatori(){

ArrayList<Utilizatori>lista_utilizatori = new ArrayList<>();


ResultSet rs;


String query = "SELECT ìd`, `nume_utilizator`, `parola`, `tip_utilizator`, `nume`, `tel`,

èmail` FROM ùtilizatori` WHERE `tip_utilizator` = 'user'";

try {



Utilizatori utilizator;

while(rs.next()){

utilizator = new Utilizatori(rs.getInt("id"),

rs.getString("nume_utilizator"),

rs.getString("parola"),

rs.getString("tip_utilizator"),



rs.getString("email")

);

lista_utilizatori.add(utilizator);

}



}

return lista_utilizatori;

}

// adaugare utilizator

public static void adaugareUtilizator(Utilizatori utilizator)

89

{



try {

ps = con.prepareStatement("INSERT INTO ùtilizatori`(`nume_utilizator`, `parola`,

`tip_utilizator`, `nume`, `tel`, èmail`) VALUES (?,?,?,?,?,?)");



ps.setString(3, "user");// administratorul va adauga un utilizator nou





JOptionPane.showMessageDialog(null, "Ați adăugat un utilizator nou");

}

else{


}



}

}

// editare utilizator

public static void editareUtilizator(Utilizatori utilizator)

{



try {

ps = con.prepareStatement("UPDATE ùtilizatori` SET

`nume_utilizator`=?,`parola`=?,`nume`=?,`tel`=?,èmail`=? WHERE ìd`=?");






ps.setInt(6, utilizator.getId());



90

}

else{


}



}

}

// stergere utilizator

public static void stergereUtilizator(Integer utilizatorId)

{



try {

ps = con.prepareStatement("DELETE FROM `utilizatori` WHERE `id` = ?");

ps.setInt(1, utilizatorId);


int YesOrNo = JOptionPane.showConfirmDialog(null,"Doriți să ștergeți acest

utilizator?","Șterge Utilizator", JOptionPane.YES_NO_OPTION);

if(YesOrNo == 0){


JOptionPane.showMessageDialog(null, "Utilizator Șters");

}

else{


}

}



}

}

}

91

Folder forms(ferestre)

Home

package forms;

import java.awt.Dimension;

import javax.swing.JFrame;

/**

*

* @author Mihaela

*/

public class Home extends javax.swing.JFrame {

public Home() {

initComponents();

}

private void jButton_UTILIZATORIMouseClicked(java.awt.event.MouseEvent evt) {

Manageriere_Utilizatori userForm = new Manageriere_Utilizatori();

userForm.pack();

userForm.setVisible(true);

userForm.setLocationRelativeTo(null);

userForm.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}

private void jButton_CATEGORIIActionPerformed(java.awt.event.ActionEvent evt) {

Manageriere_Categorii categoryForm = new Manageriere_Categorii();

categoryForm.pack();

categoryForm.setVisible(true);

categoryForm.setLocationRelativeTo(null);

categoryForm.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}

private void jButton_CLIENTIActionPerformed(java.awt.event.ActionEvent evt) {

Manageriere_Clienti customerForm = new Manageriere_Clienti();

customerForm.pack();

customerForm.setVisible(true);

customerForm.setLocationRelativeTo(null);

customerForm.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}

private void jButton_PRODUCATORIActionPerformed(java.awt.event.ActionEvent evt) {

Manageriere_Producatori producatoriForm = new Manageriere_Producatori();

92

producatoriForm.pack();

producatoriForm.setVisible(true);

producatoriForm.setLocationRelativeTo(null);

producatoriForm.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}

private void jButton_DISPOZITIVEActionPerformed(java.awt.event.ActionEvent evt) {

Manageriere_Dispozitive productForm = new Manageriere_Dispozitive();

productForm.pack();

productForm.setVisible(true);

productForm.setLocationRelativeTo(null);

productForm.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

}

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {

@Override

public void run() {

new Home().setVisible(true);

}

});

}

// Variables declaration - do not modify

private javax.swing.JButton jButton_CATEGORII;

private javax.swing.JButton jButton_CLIENTI;

private javax.swing.JButton jButton_DISPOZITIVE;

private javax.swing.JButton jButton_PRODUCATORI;

public javax.swing.JButton jButton_UTILIZATORI;

private javax.swing.JComboBox<String> jComboBox1;

private javax.swing.JLabel jLabel1;








private javax.swing.JPanel jPanel1;




private javax.swing.JProgressBar jProgressBar1;

// End of variables declaration

}

Logare

package forms;

import java.awt.Dimension;

93

import java.awt.Font;

import java.awt.font.TextAttribute;




import java.util.Map;



import javax.swing.JFrame;


import javax.swing.UIManager;

/**

*


*/

public class Logare extends javax.swing.JFrame {

/**

* Creates new form Login_Form

*/

public Logare() {

initComponents();

}

// button login form

private void jButton_LOGINActionPerformed(java.awt.event.ActionEvent evt) {


ResultSet rs;

try {

ps = clase.conectare_bd.BD_INFO.getConnection().prepareStatement("SELECT

`nume_utilizator`, `parola` , `tip_utilizator` FROM `utilizatori` WHERE `nume_utilizator` = ? AND

`parola` = ?");

ps.setString(1, jTextField_Nume_Utilizator.getText());

ps.setString(2, String.valueOf(jPasswordField_Parola.getPassword()));


if(rs.next()){

Home homeForm = new Home();

if(rs.getString("tip_utilizator").equals("user"))

{

94

homeForm.jButton_UTILIZATORI.setVisible(false);

}

homeForm.pack();

homeForm.setExtendedState(homeForm.getExtendedState() |

JFrame.MAXIMIZED_BOTH);

Dimension r = homeForm.getBounds().getSize();

homeForm.setVisible(true);

homeForm.setLocationRelativeTo(null);

homeForm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

this.dispose();

}else{

JOptionPane.showMessageDialog(null, "Nume de Utilizator sau Parolă

Incorecte","Eroare",2);

}


Logger.getLogger(Logare.class.getName()).log(Level.SEVERE, null, ex);

}

}

private void jPasswordField_ParolaActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

}

private void jTextField_Nume_UtilizatorActionPerformed(java.awt.event.ActionEvent evt) {


}



@Override

public void run() {

new Logare().setVisible(true);

}

});

}


private javax.swing.JButton jButton_LOGIN;




95




private javax.swing.JPasswordField jPasswordField_Parola;

private javax.swing.JTextField jTextField_Nume_Utilizator;


}

Manageriere_Categorii

package forms;

import java.awt.Color;




import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

/**

*


*/

public final class Manageriere_Categorii extends javax.swing.JFrame {

public Manageriere_Categorii() {

initComponents();

populateJtable();

jTable_CATEGORII.setShowGrid(true);

jTable_CATEGORII.setGridColor(Color.BLACK);

jTable_CATEGORII.setSelectionBackground(Color.gray);

JTableHeader th = jTable_CATEGORII.getTableHeader();

th.setFont(new Font("Tahoma", Font.PLAIN, 16));

}

// function to populate the jtable with data

public void populateJtable(){

clase.model.Categorii categorie = new clase.model.Categorii();

ArrayList<clase.model.Categorii> ListaCategorii = categorie.listaCategorii();

96

String[] colNames = {"Id","Denumire"};

Object[][] rows = new Object[ListaCategorii.size()][2];

DefaultTableModel model = (DefaultTableModel) jTable_CATEGORII.getModel();

for(int i = 0; i < ListaCategorii.size(); i++){

rows[i][0] = ListaCategorii.get(i).getId();

rows[i][1] = ListaCategorii.get(i).getDenumire();

}

model.setDataVector(rows, colNames);

jTable_CATEGORII.setModel(model);

jTable_CATEGORII.setRowHeight(30);

jTable_CATEGORII.getColumnModel().getColumn(0).setPreferredWidth(50);

jTable_CATEGORII.getColumnModel().getColumn(1).setPreferredWidth(300);

}

// stergere

private void jButton_STERGE_ActionPerformed(java.awt.event.ActionEvent evt) {

try{

Integer id = Integer.valueOf(jTextField_ID.getText());

clase.model.Categorii.stergereCategorie(id);

populateJtable();

}catch(Exception ex){

JOptionPane.showMessageDialog(null, "Selectează o categorie", "Nu ați selectat nici o

categorie", 1);

}

}

// editare

private void jButton_EDITEAZA_ActionPerformed(java.awt.event.ActionEvent evt) {

try{

if(verifFields())

{

String denumire = jTextField_DENUMIRE.getText();


clase.model.Categorii categorie = new clase.model.Categorii(id, denumire);

clase.model.Categorii.editareCategorie(categorie);

populateJtable();

}


97

JOptionPane.showMessageDialog(null, "Selectează o categorie pentru a efectua editarea",

"Nu ați selectat nici o categorie", 1);

}

}

// adaugare

private void jButton_ADAUGA_ActionPerformed(java.awt.event.ActionEvent evt) {

if(verifFields())

{


clase.model.Categorii categorie = new clase.model.Categorii(null, denumire);

clase.model.Categorii.adaugareCategorie(categorie);

populateJtable();

}

}

//resetare cîmpuri

private void jButton_STERGE_TOTActionPerformed(java.awt.event.ActionEvent evt) {

// textfields

jTextField_ID.setText("");

jTextField_DENUMIRE.setText("");

}

// tabel clienti

private void jTable_CATEGORII_MouseClicked(java.awt.event.MouseEvent evt) {

try{

Integer rowIndex = jTable_CATEGORII.getSelectedRow();

jTextField_ID.setText(jTable_CATEGORII.getValueAt(rowIndex, 0).toString());

jTextField_DENUMIRE.setText(jTable_CATEGORII.getValueAt(rowIndex, 1).toString());


}

}

// verificare campuri

public boolean verifFields()

{

if(jTextField_DENUMIRE.getText().equals(""))

{

98

JOptionPane.showMessageDialog(null, "Completați câmpurile goale", "Câmp gol", 0);

return false;

}else{

return true;

}

}



@Override

public void run() {

new Manageriere_Categorii().setVisible(true);

}

});

}


private javax.swing.JButton jButton_ADAUGA_;

private javax.swing.JButton jButton_EDITEAZA_;

private javax.swing.JButton jButton_STERGE_;

private javax.swing.JButton jButton_STERGE_TOT;



private javax.swing.JLabel jLabel_ID1;

private javax.swing.JLabel jLabel_NUME1;



private javax.swing.JScrollPane jScrollPane2;

private javax.swing.JTable jTable_CATEGORII;

private javax.swing.JTextField jTextField_DENUMIRE;

private javax.swing.JTextField jTextField_ID;


}

Manageriere_Clienti

package forms;











/**

99

*


*/

public final class Manageriere_Clienti extends javax.swing.JFrame {

public Manageriere_Clienti() {

initComponents();

populateJtable();

jTable_CLIENTI_.setShowGrid(true);

jTable_CLIENTI_.setGridColor(Color.BLACK);

jTable_CLIENTI_.setSelectionBackground(Color.gray);

JTableHeader th = jTable_CLIENTI_.getTableHeader();


}

// function to populate the jtable with customers data


clase.model.Clienti client = new clase.model.Clienti();

ArrayList<clase.model.Clienti> ListaClienti = client.listaClienti();

String[] colNames =

{"Id","Nume","Director","Adresă","Telefon","Email","IBAN","IDNO","Bancă"};

Object[][] rows = new Object[ListaClienti.size()][9];

DefaultTableModel model = (DefaultTableModel) jTable_CLIENTI_.getModel();

for(int i = 0; i < ListaClienti.size(); i++){

rows[i][0] = ListaClienti.get(i).getId();

rows[i][1] = ListaClienti.get(i).getNume();

rows[i][2] = ListaClienti.get(i).getPersoana_Contact();

rows[i][3] = ListaClienti.get(i).getAdresa();

rows[i][4] = ListaClienti.get(i).getTel();

rows[i][5] = ListaClienti.get(i).getEmail();

rows[i][6] = ListaClienti.get(i).getIban();

rows[i][7] = ListaClienti.get(i).getIdno();

rows[i][8] = ListaClienti.get(i).getBanca();

}


jTable_CLIENTI_.setModel(model);

100

jTable_CLIENTI_.setRowHeight(30);

jTable_CLIENTI_.getColumnModel().getColumn(0).setPreferredWidth(50);









}

// tabel clienti

private void jTable_CLIENTI_MouseClicked(java.awt.event.MouseEvent evt) {

try{

Integer rowIndex = jTable_CLIENTI_.getSelectedRow();

jTextField_ID.setText(jTable_CLIENTI_.getValueAt(rowIndex, 0).toString());

jTextField_NUME.setText(jTable_CLIENTI_.getValueAt(rowIndex, 1).toString());

jTextField_PERSOANA_CONTACT.setText(jTable_CLIENTI_.getValueAt(rowIndex,

2).toString());

jTextField_ADRESA.setText(jTable_CLIENTI_.getValueAt(rowIndex, 3).toString());

jTextField_TELEFON.setText(jTable_CLIENTI_.getValueAt(rowIndex, 4).toString());

jTextField_EMAIL.setText(jTable_CLIENTI_.getValueAt(rowIndex, 5).toString());

jTextField_IBAN.setText(jTable_CLIENTI_.getValueAt(rowIndex, 6).toString());

jTextField_IDNO.setText(jTable_CLIENTI_.getValueAt(rowIndex, 7).toString());

jTextField_BANCA.setText(jTable_CLIENTI_.getValueAt(rowIndex, 8).toString());


}

}

// adaugare


if(verifFields())

101

{

String nume = jTextField_NUME.getText();

String persoana_contact = jTextField_PERSOANA_CONTACT.getText();

String adresa = jTextField_ADRESA.getText();

String tel = jTextField_TELEFON.getText();

String email = jTextField_EMAIL.getText();

String iban = jTextField_IBAN.getText();

String idno = jTextField_IDNO.getText();

String banca = jTextField_BANCA.getText();

clase.model.Clienti client = new clase.model.Clienti(null, nume, persoana_contact, adresa,

tel, email, iban, idno, banca );

clase.model.Clienti.adaugareClient(client);

populateJtable();

}

}

// editare


try{

if(verifFields())

{

String nume = jTextField_NUME.getText();





String iban = jTextField_IBAN.getText();

String idno = jTextField_IDNO.getText();

String banca = jTextField_BANCA.getText();


clase.model.Clienti client = new clase.model.Clienti(id, nume, persoana_contact, adresa,

tel, email, iban, idno, banca);

clase.model.Clienti.editareClient(client);

populateJtable();

}


JOptionPane.showMessageDialog(null, "Selectează un client pentru a efectua editarea",

"Nu ați selectat nici un client", 1);

}

}

// stergere


102

try{


clase.model.Clienti.stergereClient(id);

populateJtable();


JOptionPane.showMessageDialog(null, "Selectează un client pentru a efectua ștergerea",

"Nu ați selectat nici un client", 1);

}

}

//resetare cîmpuri


// textfields


jTextField_NUME.setText("");

jTextField_PERSOANA_CONTACT.setText("");

jTextField_ADRESA.setText("");

jTextField_TELEFON.setText("");

jTextField_EMAIL.setText("");

jTextField_IBAN.setText("");

jTextField_IDNO.setText("");

jTextField_BANCA.setText("");

}



{

if(jTextField_NUME.getText().equals("") ||

jTextField_PERSOANA_CONTACT.getText().equals("")||

jTextField_ADRESA.getText().equals("") ||

jTextField_TELEFON.getText().equals("")||

jTextField_EMAIL.getText().equals("")||

jTextField_IBAN.getText().equals("")||

jTextField_IDNO.getText().equals("")||

jTextField_BANCA.getText().equals(""))

{


return false;

}else{

103

return true;

}

}



@Override

public void run() {

new Manageriere_Clienti().setVisible(true);

}

});

}








private javax.swing.JLabel jLabel_ADRESA;

private javax.swing.JLabel jLabel_BANCA;

private javax.swing.JLabel jLabel_EMAIL;

private javax.swing.JLabel jLabel_IBAN;

private javax.swing.JLabel jLabel_ID;

private javax.swing.JLabel jLabel_IDNO;

private javax.swing.JLabel jLabel_NUME;

private javax.swing.JLabel jLabel_PERSOANA_CONTACT;

private javax.swing.JLabel jLabel_TELEFON;




private javax.swing.JTable jTable_CLIENTI_;

private javax.swing.JTextField jTextField_ADRESA;

private javax.swing.JTextField jTextField_BANCA;

private javax.swing.JTextField jTextField_EMAIL;

private javax.swing.JTextField jTextField_IBAN;


private javax.swing.JTextField jTextField_IDNO;

private javax.swing.JTextField jTextField_NUME;

private javax.swing.JTextField jTextField_PERSOANA_CONTACT;

private javax.swing.JTextField jTextField_TELEFON;


}

Manageriere_Dispozitive

package forms;

104



import java.awt.Image;

import java.io.IOException;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;


import javax.swing.ImageIcon;


import javax.swing.RowFilter;



import javax.swing.table.TableRowSorter;

/**

*


*/

public final class Manageriere_Dispozitive extends javax.swing.JFrame {

public Manageriere_Dispozitive() {

initComponents();

populateJtable();

jTable_DISPOZITIVE_.setShowGrid(true);

jTable_DISPOZITIVE_.setGridColor(Color.BLACK);

jTable_DISPOZITIVE_.setSelectionBackground(Color.gray);

JTableHeader th = jTable_DISPOZITIVE_.getTableHeader();


}



clase.model.Dispozitive dispozitiv = new clase.model.Dispozitive();

ArrayList<clase.model.Dispozitive> ListaDispozitive = dispozitiv.listaDispozitive();

105

String[] colNames =

{"Id","Denumire","Categorie","Producător","Model","Descriere","Preț","Cantitate","Garanție"};

Object[][] rows = new Object[ListaDispozitive.size()][9];

DefaultTableModel model = (DefaultTableModel) jTable_DISPOZITIVE_.getModel();

for(int i = 0; i < ListaDispozitive.size(); i++){

rows[i][0] = ListaDispozitive.get(i).getId();

rows[i][1] = ListaDispozitive.get(i).getDenumire();

rows[i][2] = ListaDispozitive.get(i).getCategorie();

rows[i][3] = ListaDispozitive.get(i).getProducator();

rows[i][4] = ListaDispozitive.get(i).getModel();

rows[i][5] = ListaDispozitive.get(i).getDescriere();

rows[i][6] = ListaDispozitive.get(i).getPret();

rows[i][7] = ListaDispozitive.get(i).getCantitate();

rows[i][8] = ListaDispozitive.get(i).getGarantie();

}


jTable_DISPOZITIVE_.setModel(model);

jTable_DISPOZITIVE_.setRowHeight(30);

jTable_DISPOZITIVE_.getColumnModel().getColumn(0).setPreferredWidth(50);









}

// tabel dispozitive

private void jTable_DISPOZITIVE_MouseClicked(java.awt.event.MouseEvent evt) {

try{

Integer rowIndex = jTable_DISPOZITIVE_.getSelectedRow();

jTextField_ID.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex, 0).toString());

jTextField_DENUMIRE.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

1).toString());

jTextField_CATEGORIE.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

2).toString());

jTextField_PRODUCATOR.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

3).toString());

jTextField_MODEL.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

4).toString());

jTextField_Descriere.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

5).toString());

106

jTextField_PRET.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex, 6).toString());

jTextField_CANTITATE.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

7).toString());

jTextField_GARANTIE.setText(jTable_DISPOZITIVE_.getValueAt(rowIndex,

8).toString());


}

}

// adaugare


if(verifFields())

{


String categorie = jTextField_CATEGORIE.getText();

String producator = jTextField_PRODUCATOR.getText();

String model = jTextField_MODEL.getText();

String pret = jTextField_PRET.getText();

String cantitate = jTextField_CANTITATE.getText();

String garantie = jTextField_GARANTIE.getText();

String descriere = jTextField_Descriere.getText();

clase.model.Dispozitive dispozitiv = new clase.model.Dispozitive(null, denumire,

categorie, producator, model, descriere, pret, cantitate, garantie );

clase.model.Dispozitive.adaugareDispozitiv(dispozitiv);

populateJtable();

}

}

// editare


try{

if(verifFields())

{


String categorie = jTextField_CATEGORIE.getText();

String producator = jTextField_PRODUCATOR.getText();

String model = jTextField_MODEL.getText();

String pret = jTextField_PRET.getText();

String cantitate = jTextField_CANTITATE.getText();

String garantie = jTextField_GARANTIE.getText();

String descriere = jTextField_Descriere.getText();

107


clase.model.Dispozitive dispozitiv = new clase.model.Dispozitive(id, denumire, categorie,

producator, model, descriere, pret, cantitate, garantie );

clase.model.Dispozitive.editareDispozitiv(dispozitiv);

populateJtable();

}


JOptionPane.showMessageDialog(null, "Selectează un dispozitiv pentru a efectua

editarea", "Nu ați selectat nici un dispozitiv", 1);

}

}

// stergere


try{


clase.model.Dispozitive.stergereDispozitiv(id);

populateJtable();


JOptionPane.showMessageDialog(null, "Selectează un dispozitiv pentru a efectua

ștergerea", "Nu ați selectat nici un dispozitiv", 1);

}

}

//resetare cîmpuri


// textfields



jTextField_CATEGORIE.setText("");

jTextField_PRODUCATOR.setText("");

jTextField_MODEL.setText("");

jTextField_PRET.setText("");

jTextField_CANTITATE.setText("");

jTextField_GARANTIE.setText("");

jTextField_Descriere.setText("");

}

108



{

if(jTextField_DENUMIRE.getText().equals("") ||

jTextField_CATEGORIE.getText().equals("")||

jTextField_PRODUCATOR.getText().equals("") ||

jTextField_MODEL.getText().equals("")||

jTextField_PRET.getText().equals("")||

jTextField_CANTITATE.getText().equals("")||

jTextField_GARANTIE.getText().equals("")||

jTextField_Descriere.getText().equals(""))

{


return false;

}else{

return true;

}

}



@Override

public void run() {

new Manageriere_Dispozitive().setVisible(true);

}

});

}









private javax.swing.JLabel jLabel_BANCA;








109




private javax.swing.JTable jTable_DISPOZITIVE_;

private javax.swing.JTextField jTextField_CANTITATE;

private javax.swing.JTextField jTextField_CATEGORIE;


private javax.swing.JTextField jTextField_Descriere;

private javax.swing.JTextField jTextField_GARANTIE;


private javax.swing.JTextField jTextField_MODEL;

private javax.swing.JTextField jTextField_PRET;

private javax.swing.JTextField jTextField_PRODUCATOR;


}

Manageriere_Producatori

package forms;











/**

*


*/

public class Manageriere_Producatori extends javax.swing.JFrame {

public Manageriere_Producatori() {

initComponents();

populateJtable();

jTable_PRODUCATORI_.setShowGrid(true);

jTable_PRODUCATORI_.setGridColor(Color.BLACK);

jTable_PRODUCATORI_.setSelectionBackground(Color.gray);

JTableHeader th = jTable_PRODUCATORI_.getTableHeader();

110


}



clase.model.Producatori producator = new clase.model.Producatori();

ArrayList<clase.model.Producatori> ListaProducatori = producator.listaProducatori();

String[] colNames = {"Id","Denumire","Persoană

Contact","Adresă","Telefon","Email","Site","Autorizație"};

Object[][] rows = new Object[ListaProducatori.size()][8];

DefaultTableModel model = (DefaultTableModel) jTable_PRODUCATORI_.getModel();

for(int i = 0; i < ListaProducatori.size(); i++){

rows[i][0] = ListaProducatori.get(i).getId();

rows[i][1] = ListaProducatori.get(i).getDenumire();

rows[i][2] = ListaProducatori.get(i).getPersoana_Contact();

rows[i][3] = ListaProducatori.get(i).getAdresa();

rows[i][4] = ListaProducatori.get(i).getTel();

rows[i][5] = ListaProducatori.get(i).getEmail();

rows[i][6] = ListaProducatori.get(i).getSite();

rows[i][7] = ListaProducatori.get(i).getAutorizatie();

}


jTable_PRODUCATORI_.setModel(model);

jTable_PRODUCATORI_.setRowHeight(30);

jTable_PRODUCATORI_.getColumnModel().getColumn(0).setPreferredWidth(50);








}

// tabel clienti

private void jTable_PRODUCATORI_MouseClicked(java.awt.event.MouseEvent evt) {

try{

111

Integer rowIndex = jTable_PRODUCATORI_.getSelectedRow();

jTextField_ID.setText(jTable_PRODUCATORI_.getValueAt(rowIndex, 0).toString());

jTextField_DENUMIRE.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

1).toString());

jTextField_PERSOANA_CONTACT.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

2).toString());

jTextField_ADRESA.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

3).toString());

jTextField_TELEFON.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

4).toString());

jTextField_EMAIL.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

5).toString());

jTextField_SITE.setText(jTable_PRODUCATORI_.getValueAt(rowIndex, 6).toString());

jTextField_AUTORIZATIE.setText(jTable_PRODUCATORI_.getValueAt(rowIndex,

7).toString());


}

}

// adaugare


if(verifFields())

{






String site = jTextField_SITE.getText();

String autorizatie = jTextField_AUTORIZATIE.getText();

clase.model.Producatori producator = new clase.model.Producatori(null, denumire,

persoana_contact, adresa, tel, email, site, autorizatie);

clase.model.Producatori.adaugareProducator(producator);

populateJtable();

}

}

// editare

112


try{

if(verifFields())

{






String site = jTextField_SITE.getText();

String autorizatie = jTextField_AUTORIZATIE.getText();


clase.model.Producatori producator = new clase.model.Producatori(id, denumire,

persoana_contact, adresa, tel, email, site, autorizatie);

clase.model.Producatori.editareProducator(producator);

populateJtable();

}


JOptionPane.showMessageDialog(null, "Selectează un producător pentru a efectua

editarea", "Nu ați selectat nici un producător", 1);

}

}

// stergere


try{


clase.model.Producatori.stergereProducator(id);

populateJtable();


JOptionPane.showMessageDialog(null, "Selectează un producător pentru a efectua

ștergerea", "Nu ați selectat nici un producător", 1);

}

}

//resetare cîmpuri


// textfields



113

jTextField_PERSOANA_CONTACT.setText("");

jTextField_ADRESA.setText("");



jTextField_SITE.setText("");

jTextField_AUTORIZATIE.setText("");

}

private void jTextField_AUTORIZATIEActionPerformed(java.awt.event.ActionEvent evt) {


}



{

if(jTextField_DENUMIRE.getText().equals("") ||

jTextField_PERSOANA_CONTACT.getText().equals("")||

jTextField_ADRESA.getText().equals("") ||

jTextField_TELEFON.getText().equals("")||

jTextField_EMAIL.getText().equals("")||

jTextField_SITE.getText().equals("")||

jTextField_AUTORIZATIE.getText().equals(""))

{


return false;

}else{

return true;

}

}



@Override

public void run() {

new Manageriere_Producatori().setVisible(true);

}

});

}





114






























private javax.swing.JTable jTable_PRODUCATORI_;

private javax.swing.JTextField jTextField_ADRESA;

private javax.swing.JTextField jTextField_AUTORIZATIE;




private javax.swing.JTextField jTextField_PERSOANA_CONTACT;

private javax.swing.JTextField jTextField_SITE;



}

Manageriere_Utilizatori

package forms;







115

/**

*


*/

public final class Manageriere_Utilizatori extends javax.swing.JFrame {

public Manageriere_Utilizatori() {

initComponents();

populateJtable();

jTable_UTILIZATORI.setShowGrid(true);

jTable_UTILIZATORI.setGridColor(Color.BLACK);

jTable_UTILIZATORI.setSelectionBackground(Color.gray);

JTableHeader th = jTable_UTILIZATORI.getTableHeader();


}

// function to populate the jtable with users data


clase.model.Utilizatori utilizator = new clase.model.Utilizatori();

ArrayList<clase.model.Utilizatori> listaUtilizatori = utilizator.ListaUtilizatori();

String[] colNames = {"Id","Nume Utilizator","Parolă","Nume","Telefon","Email"};

Object[][] rows = new Object[listaUtilizatori.size()][6];

for(int i = 0; i < listaUtilizatori.size(); i++){

rows[i][0] = listaUtilizatori.get(i).getId();

rows[i][1] = listaUtilizatori.get(i).getNume_Utilizator();

rows[i][2] = listaUtilizatori.get(i).getParola();

rows[i][3] = listaUtilizatori.get(i).getNume();

rows[i][4] = listaUtilizatori.get(i).getTel();

rows[i][5] = listaUtilizatori.get(i).getEmail();

}

DefaultTableModel mmodel = new DefaultTableModel(rows, colNames);

jTable_UTILIZATORI.setModel(mmodel);

jTable_UTILIZATORI.setRowHeight(35);

116

jTable_UTILIZATORI.getColumnModel().getColumn(0).setPreferredWidth(50);






}

// get selected user data from jtable to textfields

private void jTable_UTILIZATORIMouseClicked(java.awt.event.MouseEvent evt) {

Integer rowIndex = jTable_UTILIZATORI.getSelectedRow();

jTextField_ID.setText(jTable_UTILIZATORI.getValueAt(rowIndex, 0).toString());

jTextField_NUME_UTILIZATOR.setText(jTable_UTILIZATORI.getValueAt(rowIndex,

1).toString());

jTextField_PAROLA.setText(jTable_UTILIZATORI.getValueAt(rowIndex, 2).toString());

jTextField_NUME.setText(jTable_UTILIZATORI.getValueAt(rowIndex, 3).toString());

jTextField_TELEFON.setText(jTable_UTILIZATORI.getValueAt(rowIndex, 4).toString());

jTextField_EMAIL.setText(jTable_UTILIZATORI.getValueAt(rowIndex, 5).toString());

}

// button add a new user


if(verifFields())

{

String uname = jTextField_NUME_UTILIZATOR.getText();

String pass = jTextField_PAROLA.getText();

String fname = jTextField_NUME.getText();



clase.model.Utilizatori utilizator = new

clase.model.Utilizatori(null,uname,pass,null,fname,tel,email);

clase.model.Utilizatori.adaugareUtilizator(utilizator);

populateJtable();

}

}

// button update user


try{

117

if(verifFields())

{


String uname = jTextField_NUME_UTILIZATOR.getText();

String pass = jTextField_PAROLA.getText();

String fname = jTextField_NUME.getText();



// username`, `password`, `user_type`, `fullname`, `tel`, `email

clase.model.Utilizatori utilizator = new

clase.model.Utilizatori(id,uname,pass,null,fname,tel,email);

clase.model.Utilizatori.editareUtilizator(utilizator);

populateJtable();

}

}

catch(Exception ex){

JOptionPane.showMessageDialog(null, "Selectați un utilizator pentru a edita!", "Nu ați

selectat nici un utilizator!", 1);

}

}

// button delete user


try{


clase.model.Utilizatori.stergereUtilizator(id);

populateJtable();

jButton_STERGE_TOTActionPerformed(null);


JOptionPane.showMessageDialog(null, "Selectați un utilizator", "Nu ați selectat nici un

utilizator!", 1);

}

}

// button clear all textfields



jTextField_NUME_UTILIZATOR.setText("");

jTextField_PAROLA.setText("");

jTextField_NUME.setText("");



}

118



public void run() {

new Manageriere_Utilizatori().setVisible(true);

}

});

}













private javax.swing.JLabel jLabel_Parola;




private javax.swing.JTable jTable_UTILIZATORI;



private javax.swing.JTextField jTextField_NUME;

private javax.swing.JTextField jTextField_NUME_UTILIZATOR;

private javax.swing.JTextField jTextField_PAROLA;



}

fcim.utm.md€¦ · Author: Admin Created Date: 1/4/2020 7:35:18 PM

Documents

Transcript of fcim.utm.md€¦ · Author: Admin Created Date: 1/4/2020 7:35:18 PM