fcim.utm.md€¦ · author: admin created date: 1/4/2020 7:35:18 pm
TRANSCRIPT
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.
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.
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
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
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;
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
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();
PreparedStatement ps;
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");
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
}
//editare Dispozitiv
public static void editareDispozitiv( Dispozitive dispozitiv)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `dispozitive` SET `denumire`= ?,`categorie`=
?,`producator`= ?,`model`= ?,`descriere`= ?,`pret`= ?,`cantitate`= ?,`garantie`= ? WHERE
`id`= ?");
ps.setString(1, dispozitiv.getDenumire());
ps.setString(2, dispozitiv.getCategorie());
39
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());
ps.setInt(9, dispozitiv.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere dispozitiv dupa id
public static void stergereDispozitiv(Integer dispozitivId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
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){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Dispozitiv eliminat");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
}
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.
Această opțiune conține tabelul principal de vizualizare a datelor ce conține următoarele coloane:
• Id;
• Denumire;
Coloana Id reprezintă numărul de identificare în cadrul bazei de date;
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `denumire` FROM `categorie`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Categorii categorie;
while(rs.next()){
categorie = new Categorii(rs.getInt("id"),
rs.getString("denumire")
);
lista_categorii.add(categorie);
}
} catch (SQLException ex) {
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;
De asemenea această fereastră mai conține și funcțiile de:
• 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.
Funcția Șterge Tot permite golirea câmpurilor de introducere a datelor.
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)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `categorie`(`denumire`) VALUES
(?)");
ps.setString(1, categorie.getDenumire());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat o categorie nouă");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare categorie
public static void editareCategorie(Categorii categorie)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `categorie` SET `denumire`= ? WHERE
`id`= ?");
ps.setString(1, categorie.getDenumire());
ps.setInt(2, categorie.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
43
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere categorie dupa id
public static void stergereCategorie(Integer categorieId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `categorie` WHERE `id` = ?");
ps.setInt(1, categorieId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați
această categorie?","Elimină Categorie", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Categorie eliminată");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
Întregul cod al clasei Categorii este reprezetat în Anexa 1.
În baza de date datele introduse sunt reprezentate la fel sub formă de tabel.
Î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.
Această opțiune conține tabelul principal de vizualizare a datelor ce conține următoarele coloane:
• Id;
• Denumire;
• Persoană Contact;
• Adresă;
• Telefon;
• Email;
• Site;
• Autorizație;
Coloana Id reprezintă numărul de identificare în cadrul bazei de date;
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `denumire`, `persoana_contact`, `adresa`, `tel`,
`email`, `site`, `autorizatie` FROM `producatori`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Producatori producator;
while(rs.next()){
producator = new Producatori(rs.getInt("id"),
rs.getString("denumire"),
rs.getString("persoana_contact"),
rs.getString("adresa"),
rs.getString("tel"),
rs.getString("email"),
rs.getString("site"),
rs.getString("autorizatie")
);
lista_producatori.add(producator);
}
} catch (SQLException ex) {
46
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_producatori;
}
Acestă fereastră conține și câmpurile de introducere a datelor despre:
• 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;
De asemenea această fereastră mai conține și funcțiile de:
• 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.
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 Producatori.Aceste metode sunt reprezentate în continuare:
// adaugare producator
public static void adaugareProducator(Producatori producator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `producatori`(`denumire`,
`persoana_contact`, `adresa`, `tel`, `email`, `site`, `autorizatie`) 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());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un producător nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare Denumire
public static void editareProducator(Producatori producator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `producatori` SET `denumire`=
?,`persoana_contact`= ?,`adresa`= ?,`tel`= ?,`email`= ?,`site`= ?,`autorizatie`= ? WHERE `id`=
?");
ps.setString(1, producator.getDenumire());
ps.setString(2, producator.getPersoana_Contact());
ps.setString(3, producator.getAdresa());
ps.setString(4, producator.getTel());
ps.setString(5, producator.getEmail());
ps.setString(6, producator.getSite());
ps.setString(7, producator.getAutorizatie());
ps.setInt(8, producator.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
48
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere producator dupa id
public static void stergereProducator(Integer producatorId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `producatori` WHERE `id` =
?");
ps.setInt(1, producatorId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Dooriți sa eliminați acest
producător?","Elimină Producător", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Producător eliminat");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
Întregul cod al clasei Producatori este reprezetat în Anexa 1.
În baza de date datele introduse sunt reprezentate la fel sub formă de tabel.
Î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.
Această opțiune conține tabelul principal de vizualizare a datelor ce conține următoarele coloane:
• Id;
• Nume;
• Director;
• Adresă;
• Telefon;
• Email;
• IBAN;
• IDNO;
• Bancă;
Coloana Id reprezintă numărul de identificare în cadrul bazei de date;
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `nume`, `persoana_contact`, `adresa`, `tel`,
`email`, `iban`, `idno`, `banca` FROM `clienti`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Clienti client;
while(rs.next()){
client = new Clienti(rs.getInt("id"),
rs.getString("nume"),
rs.getString("persoana_contact"),
rs.getString("adresa"),
rs.getString("tel"),
rs.getString("email"),
rs.getString("iban"),
rs.getString("idno"),
rs.getString("banca")
);
lista_clienti.add(client);
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_clienti;
}
Acestă fereastră conține și câmpurile de introducere a datelor despre:
• Numele clientului;
• Persoană de contact- directorul spitalului;
51
• Adresa clientului;
• Telefonul clientului;
• Email-ul clientului;
• IBAN-ul clientului;
• IDNO-ul clientului;
• Banca clientului;
De asemenea această fereastră mai conține și funcțiile de:
• 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.
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 Clienti.Aceste metode sunt reprezentate în continuare:
// adaugare client
public static void adaugareClient(Clienti client)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `clienti`(`nume`,
`persoana_contact`, `adresa`, `tel`, `email`, `iban`, `idno`, `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());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un client nou");
52
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare client
public static void editareClient(Clienti client)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `clienti` SET `nume`=
?,`persoana_contact`= ?,`adresa`= ?,`tel`= ?,`email`= ?,`iban`= ?,`idno`= ?,`banca`= ?
WHERE `id`= ?");
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());
ps.setInt(9, client.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere client dupa id
public static void stergereClient(Integer clientId)
53
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `clienti` WHERE `id` = ?");
ps.setInt(1, clientId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați acest
client?","Elimină Client", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Client șters");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
Întregul cod al clasei Clienti este reprezetat în Anexa 1.
În baza de date datele introduse sunt reprezentate la fel sub formă de tabel.
Î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.
Această opțiune conține tabelul principal de vizualizare a datelor ce conține următoarele coloane:
• Id;
• Nume Utilizator;
• Parolă;
• Nume;
• Telefon;
• Email;
Coloana Id reprezintă numărul de identificare în cadrul bazei de date;
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `nume_utilizator`, `parola`, `tip_utilizator`, `nume`,
`tel`, `email` FROM `utilizatori` WHERE `tip_utilizator` = 'user'";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Utilizatori utilizator;
while(rs.next()){
utilizator = new Utilizatori(rs.getInt("id"),
rs.getString("nume_utilizator"),
rs.getString("parola"),
rs.getString("tip_utilizator"),
rs.getString("nume"),
rs.getString("tel"),
rs.getString("email")
);
lista_utilizatori.add(utilizator);
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_utilizatori;
}
57
Acestă fereastră conține și câmpurile de introducere a datelor despre:
• 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;
De asemenea această fereastră mai conține și funcțiile de:
• 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.
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 Utilizatori.Aceste metode sunt reprezentate în continuare:
// adaugare utilizator
public static void adaugareUtilizator(Utilizatori utilizator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
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());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un utilizator nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
58
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare utilizator
public static void editareUtilizator(Utilizatori utilizator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `utilizatori` SET
`nume_utilizator`=?,`parola`=?,`nume`=?,`tel`=?,`email`=? WHERE `id`=?");
ps.setString(1, utilizator.getNume_Utilizator());
ps.setString(2, utilizator.getParola());
ps.setString(3, utilizator.getNume());
ps.setString(4, utilizator.getTel());
ps.setString(5, utilizator.getEmail());
ps.setInt(6, utilizator.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere utilizator
public static void stergereUtilizator(Integer utilizatorId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `utilizatori` WHERE `id` = ?");
59
ps.setInt(1, utilizatorId);
// mesaj de confirmare
int YesOrNo = JOptionPane.showConfirmDialog(null,"Doriți să ștergeți acest
utilizator?","Șterge Utilizator", JOptionPane.YES_NO_OPTION);
if(YesOrNo == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Utilizator Șters");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
Întregul cod al clasei Utilizatori este reprezentat în Anexa 1.
În baza de date datele introduse sunt reprezentate la fel sub formă de tabel.
Î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/
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.Connection;
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `denumire` FROM `categorie`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Categorii categorie;
while(rs.next()){
categorie = new Categorii(rs.getInt("id"),
rs.getString("denumire")
);
lista_categorii.add(categorie);
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
67
return lista_categorii;
}
// adaugare Categorie
public static void adaugareCategorie(Categorii categorie)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `categorie`(`denumire`) VALUES (?)");
ps.setString(1, categorie.getDenumire());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat o categorie nouă");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare categorie
public static void editareCategorie(Categorii categorie)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `categorie` SET `denumire`= ? WHERE `id`= ?");
ps.setString(1, categorie.getDenumire());
ps.setInt(2, categorie.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
68
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere categorie dupa id
public static void stergereCategorie(Integer categorieId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `categorie` WHERE `id` = ?");
ps.setInt(1, categorieId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați această
categorie?","Elimină Categorie", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Categorie eliminată");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Categorii.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Clasa Clienți
package clase.model;
import clase.conectare_bd.BD_INFO;
import java.sql.Connection;
import java.sql.PreparedStatement;
69
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
/**
*
* @author Mihaela Macari
*/
public class Clienti {
Connection connection;
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;
}
public Integer getId() {
return id;
}
public void setId(Integer 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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `nume`, `persoana_contact`, `adresa`, `tel`, `email`, `iban`,
`idno`, `banca` FROM `clienti`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Clienti client;
while(rs.next()){
client = new Clienti(rs.getInt("id"),
rs.getString("nume"),
rs.getString("persoana_contact"),
rs.getString("adresa"),
rs.getString("tel"),
rs.getString("email"),
rs.getString("iban"),
rs.getString("idno"),
rs.getString("banca")
72
);
lista_clienti.add(client);
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_clienti;
}
// adaugare client
public static void adaugareClient(Clienti client)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `clienti`(`nume`, `persoana_contact`, `adresa`,
`tel`, `email`, `iban`, `idno`, `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());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un client nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare client
public static void editareClient(Clienti client)
{
73
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `clienti` SET
`nume`= ?,`persoana_contact`= ?,`adresa`= ?,`tel`= ?,`email`= ?,`iban`= ?,`idno`= ?,`banca`= ?
WHERE `id`= ?");
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());
ps.setInt(9, client.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere client dupa id
public static void stergereClient(Integer clientId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `clienti` WHERE `id` = ?");
ps.setInt(1, clientId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Doriți să eliminați acest
client?","Elimină Client", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
74
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Client șters");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Clienti.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Clasa Dispozitive
package clase.model;
import clase.conectare_bd.BD_INFO;
import java.sql.Connection;
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 Dispozitive {
Connection connection;
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.denumire = DENUMIRE;
this.categorie = CATEGORIE;
this.producator = PRODUCATOR;
this.model = MODEL;
this.descriere = DESCRIERE;
this.pret = PRET;
this.cantitate = CANTITATE;
this.garantie = GARANTIE;
}
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;
}
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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
77
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")
);
lista_dispozitive.add(dispozitiv);
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_dispozitive;
}
// adaugare dispozitiv
public static void adaugareDispozitiv(Dispozitive dispozitiv)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
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());
78
ps.setString(8, dispozitiv.getGarantie());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un dispozitiv nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
}
//editare Dispozitiv
public static void editareDispozitiv( Dispozitive dispozitiv)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `dispozitive` SET
`denumire`= ?,`categorie`= ?,`producator`= ?,`model`= ?,`descriere`= ?,`pret`= ?,`cantitate`= ?,`gara
ntie`= ? WHERE `id`= ?");
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());
ps.setInt(9, dispozitiv.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
79
}
}
// stergere dispozitiv dupa id
public static void stergereDispozitiv(Integer dispozitivId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
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){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Dispozitiv eliminat");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Dispozitive.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Clasa Model_Tabel
package clase.model;
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
package clase.model;
import clase.conectare_bd.BD_INFO;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
/**
*
* @author Mihaela Macari
*/
public class Producatori {
Connection connection;
private Integer id;
private String denumire;
private String persoana_contact;
private String adresa;
private String tel;
private String email;
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.denumire = DENUMIRE;
this.persoana_contact = PERSOANA_CONTACT;
this.adresa = ADRESA;
this.tel = TEL;
this.email = EMAIL;
this.site = SITE;
this.autorizatie = AUTORIZATIE;
}
public Integer getId() {
82
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getDenumire() {
return denumire;
}
public void setDenumire(String denumire) {
this.denumire = 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;
}
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 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<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `denumire`, `persoana_contact`, `adresa`, `tel`, `email`,
`site`, `autorizatie` FROM `producatori`";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Producatori producator;
while(rs.next()){
producator = new Producatori(rs.getInt("id"),
rs.getString("denumire"),
rs.getString("persoana_contact"),
rs.getString("adresa"),
rs.getString("tel"),
rs.getString("email"),
rs.getString("site"),
rs.getString("autorizatie")
);
lista_producatori.add(producator);
}
} catch (SQLException ex) {
84
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_producatori;
}
// adaugare producator
public static void adaugareProducator(Producatori producator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("INSERT INTO `producatori`(`denumire`, `persoana_contact`,
`adresa`, `tel`, `email`, `site`, `autorizatie`) VALUES (?,?,?,?,?,?,?)");
ps.setString(1, producator.getDenumire());
ps.setString(2, producator.getPersoana_Contact());
ps.setString(3, producator.getAdresa());
ps.setString(4, producator.getTel());
ps.setString(5, producator.getEmail());
ps.setString(6, producator.getSite());
ps.setString(7, producator.getAutorizatie());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un producător nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare Denumire
public static void editareProducator(Producatori producator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `producatori` SET
`denumire`= ?,`persoana_contact`= ?,`adresa`= ?,`tel`= ?,`email`= ?,`site`= ?,`autorizatie`= ?
WHERE `id`= ?");
85
ps.setString(1, producator.getDenumire());
ps.setString(2, producator.getPersoana_Contact());
ps.setString(3, producator.getAdresa());
ps.setString(4, producator.getTel());
ps.setString(5, producator.getEmail());
ps.setString(6, producator.getSite());
ps.setString(7, producator.getAutorizatie());
ps.setInt(8, producator.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere producator dupa id
public static void stergereProducator(Integer producatorId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `producatori` WHERE `id` = ?");
ps.setInt(1, producatorId);
// mesaj de confirmare
int DaOrNu = JOptionPane.showConfirmDialog(null,"Dooriți sa eliminați acest
producător?","Elimină Producător", JOptionPane.YES_NO_OPTION);
if(DaOrNu == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Producător eliminat");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
86
} catch (SQLException ex) {
Logger.getLogger(Producatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Clasa Utilizatori
package clase.model;
import clase.conectare_bd.BD_INFO;
import java.sql.Connection;
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;
public class Utilizatori {
Connection connection;
private Integer id;
private String nume_utilizator;
private String parola;
private String tip_utilizator;
private String nume;
private String tel;
private String email;
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
public Integer getId() {
return id;
}
public void setId(Integer 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;
}
public String getTel() {
return tel;
}
public void setTel(String tel) {
this.tel = tel;
}
88
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
// lista utilizatori
public ArrayList<Utilizatori> ListaUtilizatori(){
ArrayList<Utilizatori>lista_utilizatori = new ArrayList<>();
connection = BD_INFO.getConnection();
ResultSet rs;
PreparedStatement ps;
String query = "SELECT `id`, `nume_utilizator`, `parola`, `tip_utilizator`, `nume`, `tel`,
`email` FROM `utilizatori` WHERE `tip_utilizator` = 'user'";
try {
ps = connection.prepareStatement(query);
rs = ps.executeQuery();
Utilizatori utilizator;
while(rs.next()){
utilizator = new Utilizatori(rs.getInt("id"),
rs.getString("nume_utilizator"),
rs.getString("parola"),
rs.getString("tip_utilizator"),
rs.getString("nume"),
rs.getString("tel"),
rs.getString("email")
);
lista_utilizatori.add(utilizator);
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
return lista_utilizatori;
}
// adaugare utilizator
public static void adaugareUtilizator(Utilizatori utilizator)
89
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
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());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Ați adăugat un utilizator nou");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// editare utilizator
public static void editareUtilizator(Utilizatori utilizator)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("UPDATE `utilizatori` SET
`nume_utilizator`=?,`parola`=?,`nume`=?,`tel`=?,`email`=? WHERE `id`=?");
ps.setString(1, utilizator.getNume_Utilizator());
ps.setString(2, utilizator.getParola());
ps.setString(3, utilizator.getNume());
ps.setString(4, utilizator.getTel());
ps.setString(5, utilizator.getEmail());
ps.setInt(6, utilizator.getId());
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Editare efectuată cu succes");
90
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
// stergere utilizator
public static void stergereUtilizator(Integer utilizatorId)
{
Connection con = BD_INFO.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("DELETE FROM `utilizatori` WHERE `id` = ?");
ps.setInt(1, utilizatorId);
// mesaj de confirmare
int YesOrNo = JOptionPane.showConfirmDialog(null,"Doriți să ștergeți acest
utilizator?","Șterge Utilizator", JOptionPane.YES_NO_OPTION);
if(YesOrNo == 0){
if(ps.executeUpdate() != 0){
JOptionPane.showMessageDialog(null, "Utilizator Șters");
}
else{
JOptionPane.showMessageDialog(null, "Eroare");
}
}
} catch (SQLException ex) {
Logger.getLogger(Utilizatori.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
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.JLabel jLabel18;
private javax.swing.JLabel jLabel19;
private javax.swing.JLabel jLabel2;
private javax.swing.JLabel jLabel3;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel3;
private javax.swing.JPanel jPanel4;
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.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
/**
*
* @author Mihaela Macari
*/
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) {
PreparedStatement ps;
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()));
rs = ps.executeQuery();
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);
}
} catch (SQLException ex) {
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) {
// TODO add your handling code here:
}
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Logare().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton_LOGIN;
private javax.swing.JLabel jLabel19;
private javax.swing.JLabel jLabel20;
private javax.swing.JLabel jLabel3;
95
private javax.swing.JLabel jLabel6;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel3;
private javax.swing.JPasswordField jPasswordField_Parola;
private javax.swing.JTextField jTextField_Nume_Utilizator;
// End of variables declaration
}
Manageriere_Categorii
package forms;
import java.awt.Color;
import java.awt.Font;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
/**
*
* @author Mihaela Macari
*/
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();
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Categorii categorie = new clase.model.Categorii(id, denumire);
clase.model.Categorii.editareCategorie(categorie);
populateJtable();
}
}catch(Exception ex){
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())
{
String denumire = jTextField_DENUMIRE.getText();
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());
}catch(Exception ex){
}
}
// 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;
}
}
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Manageriere_Categorii().setVisible(true);
}
});
}
// Variables declaration - do not modify
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 jLabel29;
private javax.swing.JLabel jLabel30;
private javax.swing.JLabel jLabel_ID1;
private javax.swing.JLabel jLabel_NUME1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel7;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTable jTable_CATEGORII;
private javax.swing.JTextField jTextField_DENUMIRE;
private javax.swing.JTextField jTextField_ID;
// End of variables declaration
}
Manageriere_Clienti
package forms;
import clase.conectare_bd.BD_INFO;
import java.awt.Color;
import java.awt.Font;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
/**
99
*
* @author Mihaela Macari
*/
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();
th.setFont(new Font("Tahoma", Font.PLAIN, 16));
}
// function to populate the jtable with customers data
public void populateJtable(){
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();
}
model.setDataVector(rows, colNames);
jTable_CLIENTI_.setModel(model);
100
jTable_CLIENTI_.setRowHeight(30);
jTable_CLIENTI_.getColumnModel().getColumn(0).setPreferredWidth(50);
jTable_CLIENTI_.getColumnModel().getColumn(1).setPreferredWidth(300);
jTable_CLIENTI_.getColumnModel().getColumn(2).setPreferredWidth(200);
jTable_CLIENTI_.getColumnModel().getColumn(3).setPreferredWidth(250);
jTable_CLIENTI_.getColumnModel().getColumn(4).setPreferredWidth(100);
jTable_CLIENTI_.getColumnModel().getColumn(5).setPreferredWidth(250);
jTable_CLIENTI_.getColumnModel().getColumn(6).setPreferredWidth(200);
jTable_CLIENTI_.getColumnModel().getColumn(7).setPreferredWidth(150);
jTable_CLIENTI_.getColumnModel().getColumn(8).setPreferredWidth(250);
}
// 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());
}catch(Exception ex){
}
}
// adaugare
private void jButton_ADAUGA_ActionPerformed(java.awt.event.ActionEvent evt) {
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
private void jButton_EDITEAZA_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
if(verifFields())
{
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();
Integer id = Integer.valueOf(jTextField_ID.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();
}
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un client pentru a efectua editarea",
"Nu ați selectat nici un client", 1);
}
}
// stergere
private void jButton_STERGE_ActionPerformed(java.awt.event.ActionEvent evt) {
102
try{
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Clienti.stergereClient(id);
populateJtable();
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un client pentru a efectua ștergerea",
"Nu ați selectat nici un client", 1);
}
}
//resetare cîmpuri
private void jButton_STERGE_TOTActionPerformed(java.awt.event.ActionEvent evt) {
// textfields
jTextField_ID.setText("");
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("");
}
// verificare campuri
public boolean verifFields()
{
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(""))
{
JOptionPane.showMessageDialog(null, "Completați câmpurile goale", "Câmp gol", 0);
return false;
}else{
103
return true;
}
}
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Manageriere_Clienti().setVisible(true);
}
});
}
// Variables declaration - do not modify
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 jLabel19;
private javax.swing.JLabel jLabel20;
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.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
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_ID;
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;
// End of variables declaration
}
Manageriere_Dispozitive
package forms;
104
import java.awt.Color;
import java.awt.Font;
import java.awt.Image;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import javax.swing.ImageIcon;
import javax.swing.JOptionPane;
import javax.swing.RowFilter;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableRowSorter;
/**
*
* @author Mihaela Macari
*/
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();
th.setFont(new Font("Tahoma", Font.PLAIN, 16));
}
// function to populate the jtable with data
public void populateJtable(){
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();
}
model.setDataVector(rows, colNames);
jTable_DISPOZITIVE_.setModel(model);
jTable_DISPOZITIVE_.setRowHeight(30);
jTable_DISPOZITIVE_.getColumnModel().getColumn(0).setPreferredWidth(50);
jTable_DISPOZITIVE_.getColumnModel().getColumn(1).setPreferredWidth(300);
jTable_DISPOZITIVE_.getColumnModel().getColumn(2).setPreferredWidth(200);
jTable_DISPOZITIVE_.getColumnModel().getColumn(3).setPreferredWidth(200);
jTable_DISPOZITIVE_.getColumnModel().getColumn(4).setPreferredWidth(200);
jTable_DISPOZITIVE_.getColumnModel().getColumn(5).setPreferredWidth(300);
jTable_DISPOZITIVE_.getColumnModel().getColumn(6).setPreferredWidth(200);
jTable_DISPOZITIVE_.getColumnModel().getColumn(7).setPreferredWidth(100);
jTable_DISPOZITIVE_.getColumnModel().getColumn(8).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());
}catch(Exception ex){
}
}
// adaugare
private void jButton_ADAUGA_ActionPerformed(java.awt.event.ActionEvent evt) {
if(verifFields())
{
String denumire = jTextField_DENUMIRE.getText();
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
private void jButton_EDITEAZA_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
if(verifFields())
{
String denumire = jTextField_DENUMIRE.getText();
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
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Dispozitive dispozitiv = new clase.model.Dispozitive(id, denumire, categorie,
producator, model, descriere, pret, cantitate, garantie );
clase.model.Dispozitive.editareDispozitiv(dispozitiv);
populateJtable();
}
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un dispozitiv pentru a efectua
editarea", "Nu ați selectat nici un dispozitiv", 1);
}
}
// stergere
private void jButton_STERGE_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Dispozitive.stergereDispozitiv(id);
populateJtable();
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un dispozitiv pentru a efectua
ștergerea", "Nu ați selectat nici un dispozitiv", 1);
}
}
//resetare cîmpuri
private void jButton_STERGE_TOTActionPerformed(java.awt.event.ActionEvent evt) {
// textfields
jTextField_ID.setText("");
jTextField_DENUMIRE.setText("");
jTextField_CATEGORIE.setText("");
jTextField_PRODUCATOR.setText("");
jTextField_MODEL.setText("");
jTextField_PRET.setText("");
jTextField_CANTITATE.setText("");
jTextField_GARANTIE.setText("");
jTextField_Descriere.setText("");
}
108
// verificare campuri
public boolean verifFields()
{
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(""))
{
JOptionPane.showMessageDialog(null, "Completați câmpurile goale", "Câmp gol", 0);
return false;
}else{
return true;
}
}
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Manageriere_Dispozitive().setVisible(true);
}
});
}
// Variables declaration - do not modify
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 jLabel19;
private javax.swing.JLabel jLabel20;
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;
109
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTable jTable_DISPOZITIVE_;
private javax.swing.JTextField jTextField_CANTITATE;
private javax.swing.JTextField jTextField_CATEGORIE;
private javax.swing.JTextField jTextField_DENUMIRE;
private javax.swing.JTextField jTextField_Descriere;
private javax.swing.JTextField jTextField_GARANTIE;
private javax.swing.JTextField jTextField_ID;
private javax.swing.JTextField jTextField_MODEL;
private javax.swing.JTextField jTextField_PRET;
private javax.swing.JTextField jTextField_PRODUCATOR;
// End of variables declaration
}
Manageriere_Producatori
package forms;
import clase.conectare_bd.BD_INFO;
import java.awt.Color;
import java.awt.Font;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
/**
*
* @author Mihaela Macari
*/
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
th.setFont(new Font("Tahoma", Font.PLAIN, 16));
}
// function to populate the jtable with data
public void populateJtable(){
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();
}
model.setDataVector(rows, colNames);
jTable_PRODUCATORI_.setModel(model);
jTable_PRODUCATORI_.setRowHeight(30);
jTable_PRODUCATORI_.getColumnModel().getColumn(0).setPreferredWidth(50);
jTable_PRODUCATORI_.getColumnModel().getColumn(1).setPreferredWidth(300);
jTable_PRODUCATORI_.getColumnModel().getColumn(2).setPreferredWidth(200);
jTable_PRODUCATORI_.getColumnModel().getColumn(3).setPreferredWidth(250);
jTable_PRODUCATORI_.getColumnModel().getColumn(4).setPreferredWidth(100);
jTable_PRODUCATORI_.getColumnModel().getColumn(5).setPreferredWidth(250);
jTable_PRODUCATORI_.getColumnModel().getColumn(6).setPreferredWidth(200);
jTable_PRODUCATORI_.getColumnModel().getColumn(7).setPreferredWidth(150);
}
// 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());
}catch(Exception ex){
}
}
// adaugare
private void jButton_ADAUGA_ActionPerformed(java.awt.event.ActionEvent evt) {
if(verifFields())
{
String denumire = jTextField_DENUMIRE.getText();
String persoana_contact = jTextField_PERSOANA_CONTACT.getText();
String adresa = jTextField_ADRESA.getText();
String tel = jTextField_TELEFON.getText();
String email = jTextField_EMAIL.getText();
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
private void jButton_EDITEAZA_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
if(verifFields())
{
String denumire = jTextField_DENUMIRE.getText();
String persoana_contact = jTextField_PERSOANA_CONTACT.getText();
String adresa = jTextField_ADRESA.getText();
String tel = jTextField_TELEFON.getText();
String email = jTextField_EMAIL.getText();
String site = jTextField_SITE.getText();
String autorizatie = jTextField_AUTORIZATIE.getText();
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Producatori producator = new clase.model.Producatori(id, denumire,
persoana_contact, adresa, tel, email, site, autorizatie);
clase.model.Producatori.editareProducator(producator);
populateJtable();
}
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un producător pentru a efectua
editarea", "Nu ați selectat nici un producător", 1);
}
}
// stergere
private void jButton_STERGE_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Producatori.stergereProducator(id);
populateJtable();
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectează un producător pentru a efectua
ștergerea", "Nu ați selectat nici un producător", 1);
}
}
//resetare cîmpuri
private void jButton_STERGE_TOTActionPerformed(java.awt.event.ActionEvent evt) {
// textfields
jTextField_ID.setText("");
jTextField_DENUMIRE.setText("");
113
jTextField_PERSOANA_CONTACT.setText("");
jTextField_ADRESA.setText("");
jTextField_TELEFON.setText("");
jTextField_EMAIL.setText("");
jTextField_SITE.setText("");
jTextField_AUTORIZATIE.setText("");
}
private void jTextField_AUTORIZATIEActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
}
// verificare campuri
public boolean verifFields()
{
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(""))
{
JOptionPane.showMessageDialog(null, "Completați câmpurile goale", "Câmp gol", 0);
return false;
}else{
return true;
}
}
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
new Manageriere_Producatori().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton_ADAUGA_;
private javax.swing.JButton jButton_EDITEAZA_;
private javax.swing.JButton jButton_STERGE_;
114
private javax.swing.JButton jButton_STERGE_TOT;
private javax.swing.JLabel jLabel19;
private javax.swing.JLabel jLabel20;
private javax.swing.JLabel jLabel21;
private javax.swing.JLabel jLabel22;
private javax.swing.JLabel jLabel23;
private javax.swing.JLabel jLabel24;
private javax.swing.JLabel jLabel25;
private javax.swing.JLabel jLabel26;
private javax.swing.JLabel jLabel27;
private javax.swing.JLabel jLabel28;
private javax.swing.JLabel jLabel29;
private javax.swing.JLabel jLabel30;
private javax.swing.JLabel jLabel_ADRESA;
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.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JPanel jPanel3;
private javax.swing.JPanel jPanel4;
private javax.swing.JPanel jPanel5;
private javax.swing.JPanel jPanel6;
private javax.swing.JPanel jPanel7;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTable jTable_PRODUCATORI_;
private javax.swing.JTextField jTextField_ADRESA;
private javax.swing.JTextField jTextField_AUTORIZATIE;
private javax.swing.JTextField jTextField_DENUMIRE;
private javax.swing.JTextField jTextField_EMAIL;
private javax.swing.JTextField jTextField_ID;
private javax.swing.JTextField jTextField_PERSOANA_CONTACT;
private javax.swing.JTextField jTextField_SITE;
private javax.swing.JTextField jTextField_TELEFON;
// End of variables declaration
}
Manageriere_Utilizatori
package forms;
import java.awt.Color;
import java.awt.Font;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
115
/**
*
* @author Mihaela Macari
*/
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();
th.setFont(new Font("Tahoma", Font.PLAIN, 16));
}
// function to populate the jtable with users data
public void populateJtable(){
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);
jTable_UTILIZATORI.getColumnModel().getColumn(1).setPreferredWidth(300);
jTable_UTILIZATORI.getColumnModel().getColumn(2).setPreferredWidth(200);
jTable_UTILIZATORI.getColumnModel().getColumn(3).setPreferredWidth(250);
jTable_UTILIZATORI.getColumnModel().getColumn(4).setPreferredWidth(200);
jTable_UTILIZATORI.getColumnModel().getColumn(5).setPreferredWidth(350);
}
// 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
private void jButton_ADAUGA_ActionPerformed(java.awt.event.ActionEvent evt) {
if(verifFields())
{
String uname = jTextField_NUME_UTILIZATOR.getText();
String pass = jTextField_PAROLA.getText();
String fname = jTextField_NUME.getText();
String tel = jTextField_TELEFON.getText();
String email = jTextField_EMAIL.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
private void jButton_EDITEAZA_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
117
if(verifFields())
{
Integer id = Integer.valueOf(jTextField_ID.getText());
String uname = jTextField_NUME_UTILIZATOR.getText();
String pass = jTextField_PAROLA.getText();
String fname = jTextField_NUME.getText();
String tel = jTextField_TELEFON.getText();
String email = jTextField_EMAIL.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
private void jButton_STERGE_ActionPerformed(java.awt.event.ActionEvent evt) {
try{
Integer id = Integer.valueOf(jTextField_ID.getText());
clase.model.Utilizatori.stergereUtilizator(id);
populateJtable();
jButton_STERGE_TOTActionPerformed(null);
}catch(Exception ex){
JOptionPane.showMessageDialog(null, "Selectați un utilizator", "Nu ați selectat nici un
utilizator!", 1);
}
}
// button clear all textfields
private void jButton_STERGE_TOTActionPerformed(java.awt.event.ActionEvent evt) {
jTextField_ID.setText("");
jTextField_NUME_UTILIZATOR.setText("");
jTextField_PAROLA.setText("");
jTextField_NUME.setText("");
jTextField_TELEFON.setText("");
jTextField_EMAIL.setText("");
}
118
/* Create and display the form */
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Manageriere_Utilizatori().setVisible(true);
}
});
}
// Variables declaration - do not modify
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 jLabel1;
private javax.swing.JLabel jLabel19;
private javax.swing.JLabel jLabel20;
private javax.swing.JLabel jLabel4;
private javax.swing.JLabel jLabel5;
private javax.swing.JLabel jLabel6;
private javax.swing.JLabel jLabel8;
private javax.swing.JLabel jLabel_Parola;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTable jTable_UTILIZATORI;
private javax.swing.JTextField jTextField_EMAIL;
private javax.swing.JTextField jTextField_ID;
private javax.swing.JTextField jTextField_NUME;
private javax.swing.JTextField jTextField_NUME_UTILIZATOR;
private javax.swing.JTextField jTextField_PAROLA;
private javax.swing.JTextField jTextField_TELEFON;
// End of variables declaration
}