PËRMBAJTJA DHE STRUKTURA E

PROJEKTIT
ABSTRAKTI...............................................................................................................................................................2
OBJEKTIVAT.............................................................................................................................................................2
FIGURAT....................................................................................................................................................................3
KAPITULLI 1............................................................................................................................................................. 4
HYRJE.........................................................................................................................................................................4
1.1 Programi që po krijohet..........................................................................................................................................4
KAPITULLI 2............................................................................................................................................................. 5
2.1 Kodi në C...............................................................................................................................................................5
2.1.1 Strukturat........................................................................................................................................................5
2.1.2 File-t............................................................................................................................................................... 6
2.2 Funksionet..............................................................................................................................................................8
2.2.1 Funksioni i menusë.........................................................................................................................................8
2.2.2 Funksioni i regjistrimit të artikullit dhe klientit...............................................................................................9
2.2.3 Funksioni për furnizimin...............................................................................................................................10
2.2.4 Funksioni për shitjen.....................................................................................................................................12
2.2.5 Funksioni për update.....................................................................................................................................13
2.2.6 Funksioni për gjendjen..................................................................................................................................14
2.2.7 Funksioni për paraqitjen e rezultateve..........................................................................................................15
2.2.8 Funksioni për kërkimin e artikujve...............................................................................................................15
2.2.9 Funksioni loadklient2() dhe loadklient3().....................................................................................................16
2.2.11 Funksionet klientet_shpesh dhe klientet_shume.........................................................................................17
2.2.12 Funksioni int main()....................................................................................................................................18
KAPITULLI 3........................................................................................................................................................... 18
3.1 Ekzekutimi i kodit................................................................................................................................................18
3.1.1 Pamja e programit.........................................................................................................................................18
3.1.2 Prova për funksionimin e kodit.....................................................................................................................19
KAPITULLI 4........................................................................................................................................................... 24
4.1 Kodi i plotë.......................................................................................................................................................... 24

Page 1
 ABSTRAKTI
Ndërtuam një program, i cili na shërbeu për të administruar një dyqan të thjeshtë. Kodi qe
i ndërtuar nga shumë funksione, me strukturat dhe punët e tyre përkatëse. U përdorën
pothuaj të gjithë njohuritë e mësuara gjatë orëve mësimore, si dhe u morën njohuri të reja
(në lidhje me vendosjen e kohës në program). U kontrolluan shumë njohuri psh. Ndërtimi
i strukturave, file-ve.
Pasi i kontrolluam pjesë-pjesë fragmentet e kodit në një faqe tjetër, programi u ndërtua
me sukses. Të gjitha komandat u ekzekutuan pa asnjë komplikim, dhe ruajtja e të
dhënave nëpër file nuk pati ndonjë error. Programi qe funksional në lidhje me kërkesat që
u dhanë dhe nëse do të donim të fshinim të dhëna mund thjesht të fshijmë file-in përkatës.

OBJEKTIVAT
 Ndërtimi i njohurive të përgjithshme për gjuhën e programimit C.
 Vendosja në paktikë e njohurive të marra.
 Kontrollimi i gabimeve në sintaksë ose drejtshkrimore.
 Krijimi i një programi sipas objektivave të dhëna.
 Ekzekutimi saktë i kodit të ndërtuar.

Page 2
 FIGURAT
Figura 1: Struktura.....................................................................................................................................6
Figura 2 dhe 3: Struktura dhe nënstruktura…………………………………………………………………………..
………………...6
Figura 4:
Variablat………………………………………………………………………………………………………………………………….7
Figura 5-8: File-t…………………………………………………………………………………………………………………………………….8

Page 3
Figura 9: Funksioni
menu.............................................................................................................................8
Figura 10 dhe 11: Regjistrimi i
artikullit......................................................................................................9
Figura 12 dhe 13: Regjistrimi i
klientit.......................................................................................................10
Figura 14-18:
Furnizimi.............................................................................................................................11
Figura 19-24: Shitja...................................................................................................................................13
Figura 25-28:
Update.................................................................................................................................14
Figura 29: Gjendja.....................................................................................................................................15
Figura 30: Paraqitja e
rezultateve..............................................................................................................15
Figura 31: Kërko
artikull............................................................................................................................15
Figura 32 dhe 33: Loadklient2 dhe
Loadklient3.........................................................................................16
Figura 34 dhe 35: Bubble
sort....................................................................................................................17
Figura 36 dhe 37: Funksionet klientet shpesh dhe
shume............................................................................18
Figura 38 dhe 39: Int
main.........................................................................................................................18
Figura 40: Pamja e
kodit............................................................................................................................19
Figura 41: Regjistrim
artikulli....................................................................................................................19
Figura 42: Regjistrim
klienti.......................................................................................................................20
Figura 43: Furnizim...................................................................................................................................20
Figura 44:
Shitja.........................................................................................................................................21

Page 4
Figura 45: Gjendja.....................................................................................................................................21
Figura 46: Klientët që blejnë më
shumë......................................................................................................22
Figura 47: Klientët që blejnë më
shpesh.....................................................................................................22
Figura 48: Kërkimi i
barkodit.....................................................................................................................23
Figura 49: Rezultatet e
përgjithshme..........................................................................................................23
Figura 50: Dalja........................................................................................................................................................................24

Page 5
 KAPITULLI 1
HYRJE

1.1 Programi që po krijohet

Po krijojmë një program që do të na shërbejë në administrimin e një dyqani të thjeshtë. Ky
program duhet të na ofrojë këto kërkesa funksionale:
1. Regjistrim Artikulli
2. Regjistrim Klienti
3. Furnizim (hyrje në dyqan)
4. Shitje (dalje nga dyqani)
5. Gjendja në magazinë
6. Klientët që blejnë më shumë (10 të parët në vlerë)
7. Klientët që blejnë më shpesh (20 të parët)
8. Kërkim artikulli sipas kodit (barcod-i)
Për artikulli do të mbahen këto të dhëna:
- kodi (8 shifra lloji EAN-8 dhe unike)
- Kategoria
- Emërtimi
- Çmim Shitje
Për Klienti do të mbahen këto të dhëna:
- ID Klienti (10 karaktere dhe unike)
- Emri
- Mbiemri
- Nr. Tel
Për një shitje do të mbahen këto të dhëna:
- ID Klienti
- ID fature
- data e shitjes
- vlera e faturës
- kodi, sasia dhe çmimi për secilin artikull
Për një furnizim do të mbahen këto të dhëna:
- ID furnizimi
- data e furnizimit
- vlera totale e furnizimit

Page 6
 - kodi, sasia dhe çmimi për secilin artikull

KAPITULLI 2
Ky kapitull flet për krijimin hap pas hapi të kodit ekzistent dhe shpjegimin për çdo hap.

2.1 Kodi në C
Gjëja e parë që bëjmë shkruajmë libraritë që do përdorim. Në rastin e kodit tonë do të përdorim:
#include <stdio.h> (libraria kryesore)
#include <string.h> (libraria për stringat)
#include <conio.h> (libraria për input/output)
#include <time.h> (libraria për kohën/datën)

2.1.1 Strukturat
Fillimisht për të organizuar të dhënat krijojmë struktura për secilën nga funksionet e përmendura
në detyrën e programit. Për të krijuar një strukturë përdorim deklarimin struct:

Për nënkategoritë e pëmendura më sipër përdorim int (integer) për vlera më numra dhe char
(character) për fjalë të caktuara. Kështu përcaktojmë dhe numrin maksimal të shkronjave të
secilës fjalë.

Page 7
 Figura 1: Struktura

Për secilën strukturë vendosim nga një emërtim përkatës që do të shërbejë në përmendjen e saj
më vonë.

Struktura detaje shërben si nënstrukturë e cila na përmbledh disa të dhëna që na duhen dhe për
disa struktura të tjera.

Figura 2 dhe 3: Struktura dhe nënstruktura

2.1.2 File-t
Pasi bëmë krijimin e strukturave, krijojmë file-t. File-t do të na shërbejnë në aksesimin më të
lehtë dhe më të shpejtë të të dhënave, si dhe një organizim të kodit. File-t i ndajmë në file tekst

Page 8
(me prapashtesën .txt) dhe binar (me prapashtesën .bin ose .dat). File-t që janë krijuar në këtë
program janë të tipit .dat, sepse në këtë formë janë më lehtë të aksesueshme të dhënat.
Krijojmë variablat për numrin e artikujve, klientëve, shitjeve dhe furnizimeve, si dhe 4 stringa
më vete ku të ruajmë file-t për secilën nga këto kategori.

Figura 4: Variablat

Tashmë do të krijojmë 4 funksione void lexo**() (kjo sipas kategorisë), ku do të bëjmë mbushjen
e secilit file. Këtu përdorim strukturën standarte të krijimit të një file binar:

Page 9
 Figura 5-8: File-t

2.2 Funksionet
Funksionet i përdorim për të kryer të gjitha veprimet dhe kodet më të rëndësishme të programit.
Funksioni kryesor i funksioneve është organizimi i kodit, e bën më të lehtë aksesimin e kodit,
dhe nëse duam të gjëjmë një kod të një veprimi direkt, me anë të funksioneve e kemi më të lehtë.
Një faktori bonus i funksioneve është se e bën më ekstetik kodin, kur të veproj në int main().

2.2.1 Funksioni i menusë

Krijojmë një funksion void menu, ku të shënojmë menunë e përgjithme (çfarë butonash do të
shtypë përdoruesi).

Me anë të printf shkruajmë çfarë do t’i dali në ekran përdoruesit:

Figura 9: Funksioni menu

Page 10
2.2.2 Funksioni i regjistrimit të artikullit dhe klientit
Me anë të funksionit void regjistro_artikull dhe void regjistro_ kliente kryejmë veprimin nëse
përdoruesi do të shtyp butonin 1 ose 2:

Figura 10 dhe 11: Regjistrimi i artikullit

Për pjesën e ID-së, duhet kontrolluar nësë ka 8-shifra apo jo. Për këtë përdorim një kusht if. Pasi
marrim ID-në nga përdoruesi me funksionin gets(), nëse gjatësia e kësaj stringe (strlen) është e
ndryshme nga 8-ta, atëherë përdoruesit i del të ndryshojë ID-në.
Tashmë kontrollojmë nëse përdoruesi ka dhënë një ID, që është regjistruar më përpara në sistem.
Ndërtojmë një cikël që i merr me rradhë të gjitha ID. Nëse bëjmë një krahasim midis ID-së së
dhënë nga përdoruesi dhe ID-ve të tjera, dhe ky ndryshim del i barabartë më 0 (pra del False),
atëherë do të japi që kjo ID gjendet njëher në sistem.
Më pas vazhdojmë me hedhjen e të dhënave të tjera dhe vendosjen e cmimit për sasinë 0. Në fund i
vendosim një update, që më vonë do të shpegojmë se si e uodate-ojmë këtë artikull të ri në file.

Page 11
Të njëjtën metodë do të ndjekim dhe për regjistrimin e klientëve veç me parametrat që kemi
vendosur që në fillim për klientët. Një e veçantë tjetër për klientët është se kemi përdorur një
funksion sprintf që konverton numrin e klientëve (variabël int) të inkreminuar me 1000 në
string.

Page 12
 Figura 12 dhe 13: Regjistrimi i klientit

2.2.3 Funksioni
për furnizimin
Me void furnizim() do të
shënojmë funksionin që
do të përdorim për kryerjen e
furnizimit.

Page 13
 Figura 14-18: Furnizimi
Fillimisht vendosim nga ID e artikullit, ID-në e re të gjeneruar për furnizimin (ID + 1000).
Vendosim të dhënat mbi varablat ku marrim një struct temporal për detajet dhe artikujt dhe
vlerat i barazojmë me 0. Bëjmë një kusht do while(artikujt <10) që do të përfshijë:
Marrim një variabël ugjetArtikulli dhe me anë të funksionit bool i themi se eshte false (pra = 0).
Duke inkreminuar variablin artikuj me 1, japin artikullin dhe kodin e artikullit që dëshirojmë të
furnizojmë. Krijojmë një cikël for ku variablin i e çojmë deri në fundin e numrit të artikujve
ekzistentë. Me anë të një kushti if krahasojmë nëse ID-ja e dhënë me ID-të janë të njëjta,
ugjetArtikulli do të bëhët true. Nësë ugjetArtikulli do të vazhdojë të jetë false deri në fund të
ciklit do të trregohet se artikulli me këtë ID nuk ekziston.
Me anë të një variabli temporal do të vendosim çmimin e blerjes së produktit dhe sasinë e blerë
dhe totali do të jetë çmim herë sasi. Në vlerën totale do të vendosim këtë veprim që sapo kryem.
Për datën dhe kohën e kemi vendosim me një funksion të gatshëm të librarisë <time.h>.
Këtë sasi që regjistruam nga përsoruesi me një cikël e vendosim në sasinë që fillimisht e
shënuam 0 të artikullit ekzistent. Këtë furnizimit të këtij artikulli e vendosim në një variabël
temporale dhe rrisim artikujt.
Cikli do të ndalojë vetëm nëse përdoruesi jep shkronjën “p”. Këtë e realizojmë me një getch()
dhe break. Vendosim një funksion getchar() për të marr karakterin nga përsoruesi dhe këtu
mbyllim ciklin do while.
Në fund do të japim vlerën totale të faturës do të rrisim numrin e furnizimeve dhe do të update-
ojmë dhe file-in e furnizimeve dhe atë të artikujve.

Page 14
 2.2.4 Funksioni për shitjen
Dhe funksioni për shitjet është i ngjashëm me atë për furnizimin, por me disa ndryshime.

Figura 19-24: Shitja

Procedura për kërkimin e ID-së së klientit është e ngjashme me atë të funksionit të furnizimit. Në
çmim dhe sasi do të ngarkojmë çmimin dhe sasinë të artikullit të dhënë nga përdoruesi.

Page 15
 Kontrollojmë nëse produkti i kërkuar është
në sasi, me anë të një kushti if.

Për totalin do të veprohet njëlloj si te

furnizimi dhe në këtë rast so të zbresim
sasinë e kërkuar nga klienti ndaj sasisë
totale të gjendjes së produktit. Vendosim
orën dhe datën e shitjes me funksion të
gatshëm dhe update-ojmë file-n e shitjeve
dhe artikujt.

2.2.5 Funksioni për update

Void update() është funksioni që do të bëjë ndryshimet e reja nga furnizimet dhe shitjet e bëra në
file-t përkatëse.

Figura 25-28: Update

Këtu në varësi të secilit x (pra për x-se nga 1 te 4)

bëjmë ndryshimet në secilin file (1-shi për
artikujt, 2-shi për klientët, 3-shi për furnizimet
dhe 4-ra për shitjet).

Rihapim filet në opsionin wb (write binary) dhe

pasi kryejmë procedurat e hapjes së file-ve,
kryejmë një cikël for (ku i është deri të numri

përkatës i secilit prej kategorive të file-ve), me anë të funksionit fwrite, i rishkruajmë këto file
sipas strukturave të reja përkatëse. Në fund i mbyllim këto file.

Page 16
2.2.6 Funksioni për gjendjen
Kur përdoruesi të shtypë butonin 5, duhet të na paraqitet gjendja në magazinë. Për këtë do të
krijojmë një funksion void gjendja().

Figura 29: Gjendja

Nga struktura e artikujve që kemi krijuar që në fillim dhe e update-uar nga furnizimi dhe shitja e
produkteve, do të kemi një numër të caktuar artikujsh, secila me ID, kategorinë, emrin, çmimin
dhe një sasi të caktuar. Këto të dhëna i hedhim në program me një cikël for.

2.2.7 Funksioni për paraqitjen e rezultateve

Do të krijojmë një funksion void paraqit_rezultatet(), ku nëse përdoruesi do të shtypë gërmën
“r”, do të na paraqiten rezultatet e shitjeve, furnizimeve, artikujve dhe klientëve.

Figura 30: Paraqitja e rezultateve

Këtu me një printf të thjeshtë hendhim numirn e furnizimeve, artikujve, shitjeve dhe klientëve.

Page 17
2.2.8 Funksioni për kërkimin e artikujve
Nëse përdoruesi do të shtypë butonin 8, i ofrohet opsioni i kërkimit të artikullit. Këtë e
realizojmë me anë të funksionit void kerko_artikull().

Figura 31: Kërko artikull

Marrim barkodin nga përdoruesi përmes funksionit gets(). Krijojmë një cikël for, ku mbreda
ciklit krijojmë një kusht if ku krahasojmë barkodin e ppërdoruesit me ID e artikullit. Nëse
gjendet artikulli, do të printohen të dhënat. Nëse jo do të dali në ekran që ka error në barkod.

2.2.9 Funksioni loadklient2() dhe loadklient3()

Këto dy funksione do të na shërbejnë për të renditur klientët sipas blerejeve.

Figura 32 dhe 33: Loadklient2 dhe Loadklient3

Në loadklient2() me int blerjet do të ruajmë përkohësisht blerjet nga çdo klientë në dyqan. Do të
krijojmë një cikël brenda ciklit ku me variablin i marrim numrin e klientëve dhe me variablin j
marrim numrin e shitjeve. Nëse ID e tyre janë të njëjta, atëherë do të rrisim blerjet.

Page 18
ID-në e klientit e vendosim në strukturën temporale klient2.tmp, ndërkohë që blerjet e klientit
vendosen në të njëjtin pozicion në strukturën temporale. Të dhënat e ruajtura në strukturën
temporale i vendosim në strukturën e kl2.

Të njëjtin arsyetim do të ndjekim dhe për loadklient3() veçse në vend të blerjeve do të merremi
dhe vlerat e shpenzuara.

2.2.10 Funksionet e rradhitjes

Ka tre mënyra se si mund të rradhisin një vektor nga vlera më e madhe në atë më të vogël, dhe
një nga mënyrat është bubble sort. Për të rradhitur klientët se kush ka blerë më shumë dhe kush
ka blerë më shpesh do të pëdorim funksionet void bsortDesc() dhe bsortDesc2()

Figura 34 dhe 35: Bubble sort

Në bubble sort krahasohet elementi i parë i një vektori me atë të dytë, i dyti me të tretin e kështu
me rradhë. Për këtë merret një variabël temporale ku bëhet këmbimi mes elementëve të vektorit
dhe me anë të dy cikleve for bëhet krahasimi i elementëve. Në bsortDesc() kryejmë rradhitjen
për klientët që kanë blerë më shpesh dhe në bsortDesc2() bëhet rradhitja për vlerën më të madhe
të shpenzuar.

2.2.11 Funksionet klientet_shpesh dhe klientet_shume

Këto dy funksione do të shërbejmë për hedhjen e të dhënave në program.

Page 19
 Figura 36 dhe 37: Funksionet klientet shpesh dhe shume

Në këto 2 funksione thjesht përforim një cikël for për printimin e të dhënave.

2.2.12 Funksioni int main()

Funksioni int main() është funksioni kryesor që bën të vlefshëm të gjithë funksionet e
lartpërmendura.

Figura 38 dhe 39: Int main

Këtu deklarojmë emrat e funksioneve të treguara në figurën më lart dhe krijojmë një cikël do
while.

Në këtë cikël me kusht që variabli char k i marrë nga përdoruesi (i cili merret me funksionin
getch()) të jetë i ndryshëm nga “d”, kryhen funksionet për kategoritë e kërkuara mga programi.
Me një kusht if else if else brenda do-së, marrim vlerat e k-së nga 1 te 8-ta dhe “r” për funksionet
përkatëse dhe kur k është “d” bëhet break.

Furnizimin
KAPITULLI 3
Më këtë kapitull do të tregohet se sipas kodit që shpjeguam më sipër, si është ekzekutuar në
program dhe sa sukses ka patur programi.

3.1 Ekzekutimi i kodit

3.1.1 Pamja e programit
Pasi i bëmë Compile dhe Run programit, dhe shohim që nuk na është krijuar asnjë problem,
programi merr këtë pamje:

Page 20
 Figura 40: Pamja e kodit
Pra na tregohet menuja kryesore.

3.1.2 Prova për funksionimin e kodit

Për të provuar se kodi funksionon provojmë çdo kategori të menusë kryesore.
Zgjidhim fillimisht butonin 1 për regjistrim artikulli:

Figura 41: Regjistrim artikulli

U regjisterua në sistem një stilolaps me barkod 00000010.
Shohim për butonin 2:

Page 21
 Figura 42: Regjistrim klienti
Me ID 1008 u regjistrua në sistem një klient me emër Kristina Kaci.
Butoni 3:

Figura 43: Furnizim

Pas regjistrimit të disa artikujve në sistem, furnizova stilolapsat të cilat kushtonin nga 3 lek copa
dhe mora 100 për sasi.
Butoni 4:

Page 22
 Figura 44: Shitja
Pas regjistrimit të disa artikujve në sistem personi me ID 1008 po kryen një blerje ku ka blerë një
kompjuter dhe 3 stilolaps. Totali është 200 + 3x10 = 230.
Butoni 5:

Figura 45: Gjendja

Na doli gjendja në magazinë pas regjistrimit të disa artikujve.
Butoni 6:

Page 23
 Figura 46: Klientët që blejnë më shumë
Dolën të rradhitura ID-të e klientëve sipas vlerës së shpenzuar nga më shumë te më pak.
Butoni 7:

Figura 47: Klientët që blejnë më shpesh

Dolën në mënyrë të rradhitur ID-të e klientëve sipas numrit të blerjeve.
Butoni 8:

Page 24
 Figura 48: Kërkimi i barkodit
Mora një artikull ekzistent dhe e kontrollova barkodin, dhe dolën tamam të dhënat në sistem.
Butoni “r”:

Figura 49: Rezultatet e përgjithshme

Ja ku na tregohet numri total i artikujve, klientëve, furnizimeve dhe shitjeve në sistem, të ruajtura
këtro të dhëna në file-t binare.
Dalja nga programi:

Page 25
 Figura 50: Dalja
Programi u mbyll me sukses. Nuk pati probleme gjatë ekzekutimit.

KAPITULLI 4
Ky kapitull do të shërbejë për të treguar kodin e plotë.

4.1 Kodi i plotë

#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <time.h>

void update(int x);

struct artikulli
{
char id[50];
int cmimi;
char emri[100];
char kategoria[100];
int sasia;
} a[100];

struct klienti
{
char id[10];

Page 26
 char emri[50];
char mbiemri[50];
int nrTel;
} k[100];

struct detaje //nen-strukture

{
char artikId[50];
int sasiaA;
int cmimiA;
int totali;
};

struct shitje
{
struct detaje info[50];
char klientId[10];
int faturaid;
char data[10];
int vleraFatures;
} sh[100];

struct furnizim
{
int id;
char data[10];
int vleraFatures;
int sasiaT;
int totali;
struct detaje detaj[50];

} f[100];

struct klient2 //ketu ruhen id e cdo klienti bashke me nr e blerjeve qe ka ber secili
{
char id[10];
int nr_blerjeve;
} kl[100];

struct klient3 //ketu ruhen id e cdo klienti dhe vlera e shpenzuar ne dyqan per secilin
{
char id[10];
int vleraShpenzuar;
} kl3[100];

Page 27
int nr_artikujve;
int nr_klienteve;
int nr_shitjeve;
int nr_furnizimeve;

char f_artikuj[50]="artikuj.dat";
char f_supply[50]="supply.dat";
char f_klient[50]="klient.dat";
char f_shitje[50]="shitje.dat";

//---------------------------------------------------------------------------------------
//funksionet lexo bejne mbushjen e strukturave perkatese me infot qe ndodhen ne file

void lexoArtikujt()
{
// ARTIKULLI
FILE *f;
f=fopen(f_artikuj,"rb");
if (f==NULL)
{
printf("\nGabim ne file");
return;
}

nr_artikujve=0;

while (fread(&a[nr_artikujve], sizeof(struct artikulli), 1, f))

{
nr_artikujve++;
}
fclose(f);

void lexoKlientet()
{
// KLIENTI
FILE *f;
f=fopen(f_klient,"rb");
if (f==NULL)
{
printf("\nGabim ne file");

Page 28
 return;
}

nr_klienteve=0;

while (fread(&k[nr_klienteve], sizeof(struct klienti), 1, f))

{
nr_klienteve++;
}
fclose(f);

void lexoFurnizimet()
{
// FURNIZIM
FILE *fpt;
fpt=fopen(f_supply,"rb");
if (fpt==NULL)
{
printf("\nGabim ne file");
return;
}

nr_furnizimeve=0;

while(fread(&f[nr_furnizimeve], sizeof(struct furnizim), 1, fpt))

{
nr_furnizimeve++;
}
fclose(fpt);
}

void lexoShitjet()
{
// SHITJE
FILE *f1;
f1=fopen(f_shitje,"rb");
if (f1==NULL)
{
printf("\nGabim ne file");
return;
}

Page 29
 nr_shitjeve=0;

while(fread(&sh[nr_shitjeve], sizeof(struct shitje), 1, f1))

{
nr_shitjeve++;
}
fclose(f1);
}

void bsortDesc()
{
int i, j;
struct klient2 temp;

for (i = 0; i < nr_klienteve - 1; i++)

{
for (j = 0; j < (nr_klienteve - 1-i); j++)
{
if (kl[j].nr_blerjeve < kl[j + 1].nr_blerjeve)
{
temp = kl[j];
kl[j] = kl[j + 1];
kl[j + 1] = temp;
}
}

}
}

void bsortDesc2()
{
int i, j;
struct klient3 temp;

for (i = 0; i < nr_klienteve - 1; i++)

{
for (j = 0; j < (nr_klienteve - 1-i); j++)
{
if (kl3[j].vleraShpenzuar < kl3[j + 1].vleraShpenzuar)
{
temp = kl3[j];
kl3[j] = kl3[j + 1];
kl3[j + 1] = temp;
}

Page 30
 }

}
}

void loadklient2()
{
int blerjet = 0;
struct klient2 tmp;
for(int i=0; i<nr_klienteve; i++)
{
blerjet = 0;
for(int j=0; j<nr_shitjeve; j++)
{
if(strcmp(k[i].id, sh[j].klientId)==0)
{
blerjet++;
}
}
strcpy(tmp.id, k[i].id);
tmp.nr_blerjeve = blerjet;

kl[i] = tmp;
}
}

void loadklient3()
{
int vlera = 0; // ketu ruhet perkohesisht vlera e shpenzuar nga cdo klient ne dyqan
struct klient3 tmp;
for(int i=0; i<nr_klienteve; i++)
{
vlera = 0;
for(int j=0; j<nr_shitjeve; j++)
{
if(strcmp(k[i].id, sh[j].klientId)==0)
{
vlera += sh[j].vleraFatures;
}
}
strcpy(tmp.id, k[i].id); //id e klientit vendoset ne strukturen temporale klinet3
tmp
tmp.vleraShpenzuar = vlera; //vlera e shpenzuar per klientin vendoset ne te
njejtin pozicion ne strukturen temporale klinet3 tmp

Page 31
 kl3[i] = tmp; // te dhenat e ruajtura ne strukturen temporale tmp vendosen tek
struktura kl3
}
}

//---------------------------------------------------------------------------------------
void menu()
{
printf("\n 1 - Regjistrim artikulli");
printf("\n 2 - Regjistrim Klienti");
printf("\n 3 - Furnizim");
printf("\n 4 - Shitje");
printf("\n 5 - Gjendja ne magazine");
printf("\n 6 - 10 Klientet qe blejne me shume");
printf("\n 7 - 20 Klientet qe blejne me shpesh");
printf("\n 8 - Kerko nje artikull me barkod");
printf("\n r - Paraqit rezultate te pergjithshme");
printf("\n d - Dalja");
printf("\n Zgjedhja : ");
}
//-------------------------------------------------------------------------------------------------------------------

void regjistro_artikull()
{
char id_tmp[50];

printf("\nJepni ID e artikullit: ");

gets(id_tmp);

if(strlen(id_tmp)!=8)
{
printf("\nID duhet te permbaje vetem 8 shifra!");
return;
}

for(int i=0; i<nr_artikujve; i++)

{
if (strcmp(id_tmp, a[i].id)==0)
{
printf("Regjistrimi nuk mund te vazhdoje sepse ekziston nje artikull me
kete id ne sistem!");
return;
}

Page 32
 }

strcpy(a[nr_artikujve].id, id_tmp);

printf("Jepni Emrin e artikullit: ");

gets(a[nr_artikujve].emri);

printf("Jepni Kategorine: ");

gets(a[nr_artikujve].kategoria);

int c;
printf("Jepni cmimin: ");
scanf("%d",&c);
a[nr_artikujve].cmimi = c;
a[nr_artikujve].sasia = 0;

nr_artikujve++;

update(1);
}

void regjistro_klient()
{

char id_tmp[10];
//funksioni sprint f e konverton nr_klienteve + 1000 ne string dhe e vendos ate ne id_tmp
ku ruhet id temporale e klientit
sprintf(id_tmp, "%d", nr_klienteve+1000);

printf("\nID e gjeneruar per klientin eshte: %s", id_tmp);

for(int i=0; i<nr_klienteve; i++)

{
if (id_tmp==k[i].id)
{
printf("Regjistrimi nuk mund te vazhdoje sepse ekziston nje klient me
kete id ne sistem!");
return;
}
}

strcpy(k[nr_klienteve].id, id_tmp);

Page 33
 printf("\nJepni emrin: ");
scanf("%s",k[nr_klienteve].emri);

printf("Jepni mbiemrin: ");

scanf("%s",k[nr_klienteve].mbiemri);

int c;
printf("Jepni Nr. tel: ");
scanf("%d",&c);
k[nr_klienteve].nrTel = c;

nr_klienteve++;

update(3);
}

//-------------------------------------------------------------------------------------------------------------------

void furnizim()
{
int id_tmp = nr_furnizimeve + 1000;

printf("\n\nID e gjeneruar per furnizimin eshte: %d", id_tmp);

f[nr_furnizimeve].id = id_tmp;

int artikuj=0, vleraT=0;

char ch;
char aid[50];
int cmimi, s;
struct detaje temp;

do
{
bool ugjetArtikulli = false;
printf("\n\n+ ARTIKULLI %d ", artikuj+1);
printf("\nJepni kodin e artikullit qe po furnizoni: ");
gets(aid);

for(int i=0; i<nr_artikujve; i++)

{
if (strcmp(aid, a[i].id)==0)
{

Page 34
 ugjetArtikulli = true;
}
}

if(ugjetArtikulli == false)
{
printf("\nArtikull me kete ID nuk ekzistion! ");
return;
}

strcpy(temp.artikId, aid);

cmimi = 0;
printf("Jepni cmimin e blerjes per artikullin qe po furnizoni: ");
scanf("%d",&cmimi);
temp.cmimiA = cmimi;

s = 0;
printf("Jepni sasine: ");
scanf("%d",&s);
temp.sasiaA = s;

temp.totali = s*cmimi;

vleraT = vleraT + (s*cmimi);

printf("Totali: %d", vleraT);
//pasi marr sasine e furnizimit ja shtojme sasine dhe artikullit ne magazine

//ora dhe data e furnizimit

time_t t;
time(&t);
printf("\n Ora dhe data e ketij furnizimi: %s", ctime(&t));

for(int i=0; i<nr_artikujve; i++)

{
if (strcmp(aid, a[i].id)==0)
{
a[i].sasia += s;
}
}
f[nr_furnizimeve].detaj[artikuj] = temp;

artikuj++;

Page 35
 printf("\nNese doni ta mbyllni kete fature shtypni P");
ch = getch();

if(ch=='P' || ch=='p')
break;

getchar();
}while(artikuj<10);

printf("\nVlera totale e fatures: %d", vleraT);

f[nr_furnizimeve].vleraFatures = vleraT;
f[nr_furnizimeve].sasiaT = artikuj;

nr_furnizimeve++;

update(2);
update(1); // bejme update dhe per artikullin per te perditesuar sasine ne magazine
}

void shitje()
{
int id_tmp = nr_shitjeve + 1000;

sh[nr_shitjeve].faturaid=id_tmp;

printf("\n\nID-ja e fatures se shitjes u gjenerua: %d", id_tmp);

char kid[10];
printf("\nJepni kodin e klientit qe po kryen kete blerje: ");
gets(kid);

bool ugjetKlienti = false;

for(int i=0; i<nr_klienteve; i++)

{
if (strcmp(kid, k[i].id)==0)
{
ugjetKlienti=true;
}
}
if(ugjetKlienti)
strcpy(sh[nr_shitjeve].klientId, kid);

Page 36
else
{
printf("\nNuk ekziston nje klient me kete ID! ");
return;
}

int cmimi, sasia; //cmimi dhe sasia qe ndodhet ne magazine per cdo artikull
int s; //sasia qe kerkohet te shitet
int artikuj = 0; //nr i artikujve ne fature
char aid[50], ch;
bool ugjetArtikulli = false;
struct detaje temp;
int vleraT=0;
do
{
printf("\nJepni kodin e artikullit qe po shisni: ");
gets(aid);

for(int i=0; i<nr_artikujve; i++)

{
if (strcmp(aid, a[i].id)==0)
{
cmimi = a[i].cmimi;
sasia = a[i].sasia;
ugjetArtikulli=true;
}
}

if(ugjetArtikulli == false)
{
printf("Artikull me kete ID nuk ekzistion! ");
return;
}
strcpy(temp.artikId, aid); //ID e artikullit

printf("Cmimi i artikullit: %d", cmimi); //Cmimi

temp.cmimiA = cmimi;

int s;
printf("\nJepni sasine: ");
scanf("%d",&s);

//kontrolloj nese sasia per kete artikull eshte ne gjendje

Page 37
 if(s>sasia)
{
printf("\nSasia ne magazine per kete artikull eshte %d dhe nuk mjafton
per kete shitje! ", sasia);
return;
}

temp.sasiaA = s; // sasia
temp.totali = s*cmimi; // totali

//bejme zbritjen e sasise nga magazina per artikullin qe po shesim

for(int i=0; i<nr_artikujve; i++)
{
if (strcmp(aid, a[i].id)==0)
{
a[i].sasia = sasia - s;
}
}
sh[nr_shitjeve].info[artikuj] = temp;

vleraT = vleraT + (s*cmimi);

artikuj++;

printf("\nNese doni ta mbyllni kete fature shtypni P");

ch = getch();

if(ch=='P' || ch=='p')
break;

getchar();

}while(artikuj<10);

printf("\n Vlera totale e fatures: %d", vleraT);

sh[nr_shitjeve].vleraFatures = vleraT;

//ora dhe data e shitjes

time_t t;
time(&t);
printf("\n Ora dhe data e kesaj shitjeje: %s", ctime(&t));

nr_shitjeve++;

Page 38
 update(4);
update(1);
}
//-------------------------------------------------------------------------------------------------------------------

void update(int x)
{
FILE *fpt;
if(x == 1)
{
fpt=fopen(f_artikuj,"wb");
if (fpt==NULL)
{
return;
}
for(int i=0;i<nr_artikujve; i++)
{
fwrite(&a[i], sizeof(struct artikulli), 1, fpt);
}
printf("\nArtikujt u perditsuan me sukses.");

fclose(fpt);
}
else if(x == 2)
{
fpt=fopen(f_supply,"wb");
if (fpt==NULL)
{
return;
}
for(int i=0;i<nr_furnizimeve; i++)
{
fwrite(&f[i], sizeof(struct furnizim), 1, fpt);
}
printf("\nFurnizimi u mbyll!");

fclose(fpt);
}
else if(x == 3)
{
fpt=fopen(f_klient,"wb");
if (fpt==NULL)
{

Page 39
 return;
}
for(int i=0;i<nr_klienteve; i++)
{
fwrite(&k[i], sizeof(struct klienti), 1, fpt);
}
printf("\nKlienti u regjistrua me suskes.");

fclose(fpt);
}
else if(x == 4)
{

fpt=fopen(f_shitje,"wb");
if (fpt==NULL)
{
return;
}
for(int i=0;i<nr_shitjeve; i++)
{
fwrite(&sh[i], sizeof(struct shitje), 1, fpt);
}
printf("\nShitja perfundoi me suskes.");

fclose(fpt);
}

}
//-------------------------------------------------------------------------------------------------------------------

void gjendja()
{
printf("\n\n*** Artikujt qe ndodhen ne magazine (Gjendja) *** \n");

printf("\n+++++++++++++++++++++++++++++++\n");
for(int i=0; i<nr_artikujve; i++)
{
printf("\nID Artikulli: %s",a[i].id);
printf("\nKategoria: %s",a[i].kategoria);
printf("\nEmri: %s",a[i].emri);
printf("\nCmimi: %d",a[i].cmimi);
printf("\nSasia ne magazine: %d",a[i].sasia);
printf("\n\n+++++++++++++++++++++++++++++++\n");
}

Page 40
}

//-------------------------------------------------------------------------------------------------------------------

void klientet_shume()
{
printf("\n\n+ + + KLIENTET QE BLEJNE ME SHUME (10) + + + \n\n ");

for(int i=0; i<nr_klienteve; i++)

{
printf("\n %d - Klienti ID: %s", i+1, kl3[i].id);
printf("\n Vlera e shpenzuar: %d", kl3[i].vleraShpenzuar);
}
}

//-------------------------------------------------------------------------------------------------------------------

void klientet_shpesh()
{
printf("\n\n+ + + KLIENTET QE BLEJNE ME SHPESH (20) + + +\n\n ");

for(int i=0; i<nr_klienteve; i++)

{
printf("\n %d - Klienti ID: %s", i+1, kl[i].id);
printf("\n Nr i blerjeve: %d", kl[i].nr_blerjeve);
}
}

//-------------------------------------------------------------------------------------------------------------------

void kerko_artikull()
{
char id_tmp[50];
printf("\n\nJepni barcodin per artikullin qe do te kontrolloni: ");

gets(id_tmp);

for(int i=0; i<nr_artikujve; i++)

{
if(strcmp(id_tmp, a[i].id)==0)
{
printf("\nID Artikulli: %s",a[i].id);
printf("\nEmri: %s",a[i].emri);

Page 41
 printf("\nKategoria: %s",a[i].kategoria);
printf("\nCmimi: %d",a[i].cmimi);
return;
}
}
printf("\nArtikulli me kete barkod nuk ndodhet ne sistem! \n");

//-------------------------------------------------------------------------------------------------------------------

void paraqit_rezulatet()
{
printf("\n\nNr i artikujve ne sistem: %d",nr_artikujve);
printf("\nNr i klienteve ne sistem: %d", nr_klienteve);
printf("\nNr i furnizimeve ne sistem: %d",nr_furnizimeve);
printf("\nNr i shitjeve ne sistem: %d",nr_shitjeve);
}

//-------------------------------------------------------------------------------------------------------------------
int main()
{
//funksionet lexo bejne mbushjen e strukturave duke lexuar inforamcionet e ruajtura ne
filet perkatese
lexoArtikujt();
lexoFurnizimet();

lexoKlientet();
lexoShitjet();

loadklient2();
loadklient3();

bsortDesc();
bsortDesc2();

char k;
do
{
menu();
k=getch();
if (k=='1') regjistro_artikull();
else if (k=='2') regjistro_klient();
else if (k=='3') furnizim();

Page 42
 else if (k=='4') shitje();
else if (k=='5') gjendja();
else if (k=='6') klientet_shume();
else if (k=='7') klientet_shpesh();
else if (k=='8') kerko_artikull();
else if (k=='r') paraqit_rezulatet();
else if (k=='d') break;
printf("\n\n shtypni nje karakter per te vazhduar...");

getch();

}while (k!='d' && k!='D');

}

Page 43