From 5d0374771f8b5a91648290d853b4a188f0fcf11f Mon Sep 17 00:00:00 2001 From: abhijeet Date: Thu, 17 Sep 2020 19:22:05 +0530 Subject: [PATCH 1/6] Assignment No. 1 for evaluation --- AccountAssignment01/.classpath | 6 ++ AccountAssignment01/.project | 17 ++++ .../.settings/org.eclipse.jdt.core.prefs | 12 +++ .../bin/com/demo/bean/Account.class | Bin 0 -> 2289 bytes .../bin/com/demo/service/AccountService.class | Bin 0 -> 2721 bytes .../bin/com/demo/test/TestAccountClass.class | Bin 0 -> 1995 bytes .../src/com/demo/bean/Account.java | 85 ++++++++++++++++++ .../src/com/demo/service/AccountService.java | 78 ++++++++++++++++ .../src/com/demo/test/TestAccountClass.java | 69 ++++++++++++++ 9 files changed, 267 insertions(+) create mode 100644 AccountAssignment01/.classpath create mode 100644 AccountAssignment01/.project create mode 100644 AccountAssignment01/.settings/org.eclipse.jdt.core.prefs create mode 100644 AccountAssignment01/bin/com/demo/bean/Account.class create mode 100644 AccountAssignment01/bin/com/demo/service/AccountService.class create mode 100644 AccountAssignment01/bin/com/demo/test/TestAccountClass.class create mode 100644 AccountAssignment01/src/com/demo/bean/Account.java create mode 100644 AccountAssignment01/src/com/demo/service/AccountService.java create mode 100644 AccountAssignment01/src/com/demo/test/TestAccountClass.java diff --git a/AccountAssignment01/.classpath b/AccountAssignment01/.classpath new file mode 100644 index 00000000..51a8bbad --- /dev/null +++ b/AccountAssignment01/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/AccountAssignment01/.project b/AccountAssignment01/.project new file mode 100644 index 00000000..c6276aa3 --- /dev/null +++ b/AccountAssignment01/.project @@ -0,0 +1,17 @@ + + + AccountAssignment01 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/AccountAssignment01/.settings/org.eclipse.jdt.core.prefs b/AccountAssignment01/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..ec1937b3 --- /dev/null +++ b/AccountAssignment01/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/AccountAssignment01/bin/com/demo/bean/Account.class b/AccountAssignment01/bin/com/demo/bean/Account.class new file mode 100644 index 0000000000000000000000000000000000000000..c6b1534281f21dfff973a858e42c0c849c8f0131 GIT binary patch literal 2289 zcmaKs-EJFI6ouFE&)69|KXu|bu3H#>+Bj|#Lt9$v6w@Xq;E*OjLZEj{>}fj1_C(Hv ziZ|c^khtI#DghEnC6Kt`j)$tc_L-?0#!h8v=A1KUe{1ix&+&iH|M~~O4LnF8rjT!W z-D=zEdeuG0?p5!#THaC5Pa&Z&_1ONwu6FF+esyc_vD5MuVs2YOH5C#)yXz?AHeT)7 z_WN#ce_0`82auf~54a_@XA{xlNHrA3+qUm)JzV$P9ye1X037*lr`q5rh8uVI&95uO z%L}_yTJ_qFi8yjuOki>h3Nu+GVaRAUixko_n#*D=7@g0;L`K#wWRbc#oncXfohwB|)X+&$1GE!~lz&mv5VWQlS z1;g%&(+cS)uK%drx1R)`n#SFKe`15c0>-y}yY>Bj`yk9PdFc2}b|6u1Y9^f;+;N2Hh~Zu=27Y$^8IFquJ6FX8~=dyfBO-j2r$BUz5CF$d-7Uy2l zPB%I2d%<~0fyNf1r)cHK?X;bK8XqYnn{BIRnW*7oIRT3@x|hWYR>j1F1E)tvF3^#o zoI}cT8lTW+Q;G{opGy2^3X7wBdktru6`G+3mN-gY8XG+GW@tnxuqgstl2_w(d40(% zWQt#w_s|M2g;kRZw*{~h$uPKv%V!fMayN_HxUOJsdq@42v*yZy&xT1aiPLzCXDiMV zmPAZ$5=Sw)NBYfMq~E+l`pp}}_XHz&`}myV>^nv)zTc=k!?{ZQ7}FJXjJ!Mwm5E~% zWmNh@$6u6vq=R=cLDm>KLYgLN4(D(YIewR~nus@HaVBb#rKtT(HHo*hT1nKdirS*6 z%_T&xXpGRyQ*V}f1+wO-SLE+J`6aDa*L7Q=9_iW%$-&ZI#Pmqq5T`8pPa#i6;)nr- zxA6|2lHn?2Wml$B`4h$Y7E^jvyh(FG8IuJ`p|g6P831@ zZK~5SX_HZzAJL&2S<7dzr1`>n5AX9SEwAc1uMj&lExm~8UdXus>KYTA=wxV>!ZnsX z9Gw3>61*}p_{PZKLNs`7Wbg;LIZ%%23?=R2ZxQA7k-@j{;UHK%2x=}xl{ZHQ^PeaT z?$LS)Zv2hfgWR2GsEczaxSMO7V2$HEU%6&5F39-vU|c-G{oEJ9xO9TAPVjY9d;64j MW8n8Uy1Z{+07tfJ5dZ)H literal 0 HcmV?d00001 diff --git a/AccountAssignment01/bin/com/demo/service/AccountService.class b/AccountAssignment01/bin/com/demo/service/AccountService.class new file mode 100644 index 0000000000000000000000000000000000000000..52583b5bab7d701a42fba5fba869317c96db9e75 GIT binary patch literal 2721 zcmah~?N$?46x}x;Ob7!=AR0mxqE-VIQ-NaT%c2pD0@{YsQu{SbMi@;dX)-~ut+h(+ z1M~sf{_>B1#I>NSuH^&tMf$H#;HuqsCWIi`5|Yfh_nve1+56m+KmYmTIe;Pjq`)K4 ztrzmitdTDy%SLI%)Q#k%t`{nnopDVCK7oBVwG}Oy)2yZB)y12JZVPzIxB-2*0VrT4xWwR_0pZ*`g z$ZeaZ>qgP83Q5{Efv&{$9nVEWv$l11aJAxX75z9#F$xu`yTjx)V&7&mfOlB&13%;E#7 z=!XJl66w7q?OjQ|8oqZvh&jwF_(&kK)1TKQ!V9ZXd9z@t_*iyLtHXZA*7RF*B~51q zUN#5)-qZ~O!sMG=c+9M1pMuEVbn?`5FVMtDa#Bdfsp+CiGo4e+k}cd6XwH(3t2Zte zcYq(TdKEP_UqYk?SUsd%cJ;YnF>SZEaWE$KKfX zX-VTONK`?#q<_h<(^=WkU(3cVy>f@$vB$e2&~n?fm$N19_GDgGFK{rCPQ8iF-gJ-y zWktnptny-(4XvavR}r3DOOxUMLP+OX+)?ojzU9Q+&P!Disa`77pj8ogiv^B`hLTaP z~tX>S=S`zzsevG3E*QUcfJ2A_qmm zvJeVP{(JcbpXXk(A3SoyZI4?#=QhJ#rj$){*gO6Roqe%^P2{_Ng-Sjhqqy!7F-g&1 zQeBst{Y(w2>8F;hR5QZoIDeF6sXcDAYN?Ft6v!DxYGlzK2W|jf2{$BLwaijnEI-p% zwr#vW`a3GazOc{p3&QCt+CEmeR& zgm)oxNg8APaUz>w_nakBlMbprW@D5Zs%Q;Ww1%p^ib|^MV2N-B$l+8aYn4<=;bKy_ yP)#_0?D4i@f7kKkqM0K4i71 literal 0 HcmV?d00001 diff --git a/AccountAssignment01/bin/com/demo/test/TestAccountClass.class b/AccountAssignment01/bin/com/demo/test/TestAccountClass.class new file mode 100644 index 0000000000000000000000000000000000000000..30224dd450c88c00a6ad99a421e634bb662984f5 GIT binary patch literal 1995 zcmaJ?O>7ip7=FI)mYHscvR&v8(3XJ$wgq-6lnO0BmM-Ad7Lct)M3m|5w4HW#X0tO3 zG%@k$$)hI^7!yLGiHR7Y(MaM^W1=P|o;-WI<5`FzM0?Bc&WTlWmlZHlY5ZE+nyVm(ydDf~<8?%ljkeT#M!1-DWQXw@>xqba1ZRX%5%Kxf}muSmyT)L%tEYZ-1X z=1)5B(XazLS@LQm?XjPW#9jBJVi(^vnAOMWHn4Qpx~Usc2>cXwW3Pfe0-M9f5#kzE z4bP!ZK&eP;j(kWAGYr)#IVuK7|DmjY*$x&;RfFcsGQcYKleEKGeacv}bVDy$70te&_1ieoIVf>Cjh&W>dDGq>ceLsUNF23A#H_G(q#T<~m@IgrMXh9el}RoA)| z6kI->Nm5ARC`J?<6WFmzmv2>XP^r#XF)Z309?^jd>$51hzB$tJ-VHW)7%e zI;LateccS%EU9=wpee#xD2=E%%}dcTSm3KeCM4>-hBG)TkdmnLUM);o0?$j}FKQ@Y zLZIblOyO9lC(zwj$gc~jpkh*>qgdlZe1ERyILmt7fZ?b(&#;^|Y{x3;fwy|1;-Y|B zM=ZTx(omG%H^vc)oU3?+`uQkm`eP?5E)!^de=f8ytz6OY8m>~M6vZ`WDk8RPU1AIU zGbv{BH4SgzP1d2s;8XN*pTellvwk-}r6^fjzR9DgaMo5Ot2x2gvZ~f&j{PM{Cjn8A zMOxxc6e{lIxu{xx%^{AB#lSF^ri@D1P!zDyq>4;O(>hCDSrPwlXjxfD*a>1_7X%tO zW5?pCaFwGJl#K%qpne)2r#Q-E@Io_3ExJItk*g-OU=w$!+%ShER6y+h66q`Vka>X4 z$;Pj+eJXMC9=bC-@1s}B{#fpd<$+k{VmV03v%@D7!^xIojoly74SwJk0;Al;Z;+qQ z?{j|N?O(z3(((yv-o=MvDSG*%n@2YhgN6>z8UX;k4&T3;WxWD|q!Tl*9^N?^Zu}^tXpQIJ+p7XRX!NVNPzNPi<0i}t^0QNZQh26+Dg;gZ-n literal 0 HcmV?d00001 diff --git a/AccountAssignment01/src/com/demo/bean/Account.java b/AccountAssignment01/src/com/demo/bean/Account.java new file mode 100644 index 00000000..d45441b3 --- /dev/null +++ b/AccountAssignment01/src/com/demo/bean/Account.java @@ -0,0 +1,85 @@ +package com.demo.bean; +import java.util.Date; + +public class Account { + private int id; + private String name; + private String accountType; + private double balance; + private Date dateOfJoining; + + //Default Constructor + public Account() { + id = 0; + name = null; + accountType = null; + balance = 0; + dateOfJoining = null; + } + + //Parameterized Constructor + public Account(int id, String name, String accountType, double balance, Date dateOfJoining) { + this.id = id; + this.name = name; + this.accountType = accountType; + this.balance = balance; + this.dateOfJoining = dateOfJoining; + } + + //Method to deposite amount + public void deposit(double amount) { + this.balance = this.balance + amount; + + } + + //Method to withdraw amount + public int withdraw(double amount) { + if(this.balance-10000 >= amount) { + this.balance = this.balance - amount; + return 1; + } + return -1; + } + + //Setters and Getters Methods + public void setId(int id) { + this.id = id; + } + + public void setName(String name) { + this.name = name; + } + + public void setAccountType(String accountType) { + this.accountType = accountType; + } + + public void setBalance(double balance) { + this.balance = balance; + } + + public int getId() { + return this.id; + } + + public String getName() { + return this.name; + } + + public String getAccountType() { + return this.accountType; + } + + public double getBalance() { + return this.balance; + } + + public Date getDateOfJoining() { + return this.dateOfJoining; + } + + //Method to display object + public String toString() { + return "Id : " + id + "\nName : " + name + "\nAccount Type : " + accountType + "\nBalance : " + balance + "\nDate of Joining :" + dateOfJoining; + } +} diff --git a/AccountAssignment01/src/com/demo/service/AccountService.java b/AccountAssignment01/src/com/demo/service/AccountService.java new file mode 100644 index 00000000..0fe9a29b --- /dev/null +++ b/AccountAssignment01/src/com/demo/service/AccountService.java @@ -0,0 +1,78 @@ +package com.demo.service; +import java.text.ParseException; +import java.math.*; +import java.lang.*; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Scanner; + +import com.demo.bean.Account; + +public class AccountService { + + public static Scanner sc = new Scanner(System.in); + public static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); + + //Accept data and create accounts + public static void acceptAccountData(Account[] acc) { + for(int i=0;i Date: Sat, 19 Sep 2020 14:39:13 +0530 Subject: [PATCH 2/6] Assignment 2 for Evaluation --- AccountAssignment02/.classpath | 6 + AccountAssignment02/.project | 17 ++ .../.settings/org.eclipse.jdt.core.prefs | 12 ++ .../bin/com/demo/bean/Account.class | Bin 0 -> 2938 bytes .../bin/com/demo/bean/CurrentAccount.class | Bin 0 -> 1683 bytes .../bin/com/demo/bean/SavingAccount.class | Bin 0 -> 1851 bytes .../bin/com/demo/dao/AccountDao.class | Bin 0 -> 683 bytes .../bin/com/demo/dao/AccountDaoImpl.class | Bin 0 -> 2171 bytes .../exception/AccountNotFoundException.class | Bin 0 -> 398 bytes .../InsufficientBalanceException.class | Bin 0 -> 410 bytes .../exception/InvalidAmountException.class | Bin 0 -> 392 bytes .../bin/com/demo/service/AccountService.class | Bin 0 -> 598 bytes .../com/demo/service/AccountServiceImpl.class | Bin 0 -> 3813 bytes .../demo/test/TestAccountInheritance.class | Bin 0 -> 4289 bytes .../src/com/demo/bean/Account.java | 123 ++++++++++++++ .../src/com/demo/bean/CurrentAccount.java | 42 +++++ .../src/com/demo/bean/SavingAccount.java | 50 ++++++ .../src/com/demo/dao/AccountDao.java | 18 +++ .../src/com/demo/dao/AccountDaoImpl.java | 76 +++++++++ .../exception/AccountNotFoundException.java | 7 + .../InsufficientBalanceException.java | 7 + .../exception/InvalidAmountException.java | 7 + .../src/com/demo/service/AccountService.java | 17 ++ .../com/demo/service/AccountServiceImpl.java | 124 ++++++++++++++ .../com/demo/test/TestAccountInheritance.java | 153 ++++++++++++++++++ 25 files changed, 659 insertions(+) create mode 100644 AccountAssignment02/.classpath create mode 100644 AccountAssignment02/.project create mode 100644 AccountAssignment02/.settings/org.eclipse.jdt.core.prefs create mode 100644 AccountAssignment02/bin/com/demo/bean/Account.class create mode 100644 AccountAssignment02/bin/com/demo/bean/CurrentAccount.class create mode 100644 AccountAssignment02/bin/com/demo/bean/SavingAccount.class create mode 100644 AccountAssignment02/bin/com/demo/dao/AccountDao.class create mode 100644 AccountAssignment02/bin/com/demo/dao/AccountDaoImpl.class create mode 100644 AccountAssignment02/bin/com/demo/exception/AccountNotFoundException.class create mode 100644 AccountAssignment02/bin/com/demo/exception/InsufficientBalanceException.class create mode 100644 AccountAssignment02/bin/com/demo/exception/InvalidAmountException.class create mode 100644 AccountAssignment02/bin/com/demo/service/AccountService.class create mode 100644 AccountAssignment02/bin/com/demo/service/AccountServiceImpl.class create mode 100644 AccountAssignment02/bin/com/demo/test/TestAccountInheritance.class create mode 100644 AccountAssignment02/src/com/demo/bean/Account.java create mode 100644 AccountAssignment02/src/com/demo/bean/CurrentAccount.java create mode 100644 AccountAssignment02/src/com/demo/bean/SavingAccount.java create mode 100644 AccountAssignment02/src/com/demo/dao/AccountDao.java create mode 100644 AccountAssignment02/src/com/demo/dao/AccountDaoImpl.java create mode 100644 AccountAssignment02/src/com/demo/exception/AccountNotFoundException.java create mode 100644 AccountAssignment02/src/com/demo/exception/InsufficientBalanceException.java create mode 100644 AccountAssignment02/src/com/demo/exception/InvalidAmountException.java create mode 100644 AccountAssignment02/src/com/demo/service/AccountService.java create mode 100644 AccountAssignment02/src/com/demo/service/AccountServiceImpl.java create mode 100644 AccountAssignment02/src/com/demo/test/TestAccountInheritance.java diff --git a/AccountAssignment02/.classpath b/AccountAssignment02/.classpath new file mode 100644 index 00000000..51a8bbad --- /dev/null +++ b/AccountAssignment02/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/AccountAssignment02/.project b/AccountAssignment02/.project new file mode 100644 index 00000000..aa8d5a0a --- /dev/null +++ b/AccountAssignment02/.project @@ -0,0 +1,17 @@ + + + AccountAssignment02 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/AccountAssignment02/.settings/org.eclipse.jdt.core.prefs b/AccountAssignment02/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..ec1937b3 --- /dev/null +++ b/AccountAssignment02/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/AccountAssignment02/bin/com/demo/bean/Account.class b/AccountAssignment02/bin/com/demo/bean/Account.class new file mode 100644 index 0000000000000000000000000000000000000000..6ebe0b6740ec0dc3720e92e3a726e0f1c8249c67 GIT binary patch literal 2938 zcmaJ?Yf}?f7=BI&xw!%cq*W23h#|37ea5dSa$wu2>(r^9N z>6gy5)q*p1rv2U@)#>w|-Gs0S>P*f#@4lDkeclWI{`c440M4QsM?~SERjm|CcBNWa zw@tUOU|H3s>%|dO7n3n zdDW~t@(zTt3)*1{eHb%v7-{h_ZXoV^%NR%?DYD}RQoihj0R#I*cGAEA2IV$wUkf>`QFEE766-Az_;F`Rg}j%1tgsy@96Bh$HVoj3{%9j?XYrc*B2^#snag2hti zd?tm{n3ZJDlDHmta;u{8iGfe?nL^C0)ohp59-A(92MxT>C2*bqQ+L=9L4*rp|GC0U zuLxb>cl=yr)l--KJ_%ech^xzjVDViD*iz|~G)|_vkqNpgb6#?}CJwHLu=s5~_b!iY z^x>5Bo_GwVBfxaazz3KirJJ@_Bs*+KYRCB!4tQ&{ZZXR4$}q$z(w8WiWIYGPbk}?g zQe(FyMV){Q9fLWhsMHokNeNvIQB5-Mn5J~AMLOqch_)fU;h;V{YT|H!4ugdK*&Cqc zEnA|w(pQCpjQ*Z6 zwL%IeW~KG?i<@G_Gp*;h%~~+EiI&5aGma%{K7Sv$DG z0qz5*39m88h_JlsUCG^Q1!80k_ zNWZx$^vOM;Pi_gGBlK|qY5E)H>kLo%myEy0Nc1&E|KKBn_xU@Z0}dmqO%CFa{sJ0s zRR!kX@vAsEm4AaH`BxZSi$0-~Ega3OEllM5ws0&zu!Tu^PRUPpC%|zc0YgRU`T(7d z;t2nbA%mls!Z`An&_NA91ag%4;ZFtOf2M7mvYGDirzHHCgwIL%L;Vu}P^<@l<8(4f z04E4wiU3X$K$gGL9I~7SFs})n2>>vhEM^UAMiw*q5}D8~C7O}N%p%E6D34K-;~GGA zsUwUnzQyUa^oMWoQT|UH-Nwi1bK98XeS$}N-oH<7<5K#Hf1ldM)$|Sjp5?KPo4?bK zUn_|LE*q(lPuF6bt|i~*JlE5BnSbp4Hk&6- zVJViEy6m(-N=q-2txMX&sIS##Iu;Xgy ztys>LHjopVOd$FSBVio3v=>P^iTmy7v$W6!ILv7a2VZ6%-rWV?A7q6uu}U);*8=%z zRdDjRPz6_Z8Mmh80Uid%^K3n7&{#gpkqC!>z}z41k-N0EAYa2*fv?VPm z;p;Y#j&7I=19?m!Pxb&JlO;gD>DiXqFc7OJkZ*gpWyfan+j5gYp6&re23vqUCT9`C zWf$;e>LQhCCp?d52Y&nsLwQcyWY!|(zhM7cm}_b44eWm;?LNI|N2w2#*L`xK&QBr2Z$fm6DHv;#6$Svy4 literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/bean/CurrentAccount.class b/AccountAssignment02/bin/com/demo/bean/CurrentAccount.class new file mode 100644 index 0000000000000000000000000000000000000000..d8e703e5d17934fdde0a08916a9a5a701761b0d4 GIT binary patch literal 1683 zcmZ`(ZF3rB6g^KuAYHa3rFk(L>&Dg;s13f`hFIH#MyWK>hC%ajSr)n}>@v&J+F#&L z@PmKB8Q+Q1&ggf4l;gR(8%jcDXV{15IrrRi?{hBy{QK-L03YC+6s8nbEw5W_+Fh^M zuuZqPGw^-e4enT$H*kX#5(;jv3)d1P>kNzf?V~^>j5Qg`2tRk@?sxc1*WjJP3TpZI>$LXm1cW zono1yOOu#z>C7+%`LRHlae= zj5=O>+LNXQUL;OoA(x+&lfo5+<+Ith2TrGH`=WGR#~R+$kV7GbJTsof>bQotsq?Yf z8Bm(S`gmvd8%MSklwOiq!)0tp8;Uf>cu3sLe0>)0DlBPxp5e8OaeEk>hD5)w(|aE( zB+XvWcAE;|#Tj-@oa;Dji{}!k6^=1q zNdAHBi`YzH58gyL38!TV;4C0bRa`NKLHDV;P@En&9S;t#{;_5N3 zXWtp(y~6Lv4)Ia;rmTl34e{v^+dmT>^+%YbrP7%aa6AyJ4G;s6wt| zjbxu+ZD+p!0ds|DJ;WD@AD?6QFuQ+@ul^=zI=q4`!$J9JN?)YxWtv*jErms{jasmV w2P{|NAdFPYTyl!|E!TS^)Bt28*RM!__h5%R$ZjO5xfX}+L+ z>T4c4(=X^u(woUNGwnm)`X&8}PS=*iEykYFIXe5Y)?Rxb{qx@+e*$I8rwpYrn z2301Rp^xhYx~glz13Sy%y34dxVD$Fu7SZHsgt-kS!P^n*>~*nx?OeUJw8m#hG`76B4wf*hUDlq(T)U@2HS2;VR-p8`BT-A->vax z*7>FAtRA@K+!A@uH2Y-N1$IDS`;)k$(Enob3w5_#)Kvq+csYre6uMvZFpkT$K@S{0kSH{mMj7{?FJ$ARX;(F9! z)8_0rG9^o#g(8J7Y~AzOW3NQ@BF@J>QRuXzAzgb^(L(&DX#K9JIj&_2X zGdOf$fzxFyhLfC@QBJS;>FIO_$f487$J3jhHaJ^%O}vNq6?!;}PQ6TmhxSmVB~j^~ zsPuuTwA2iDs1mh#=my)xs{N26(397~xbuypD}n2KwIn`N$Q=!?J~ZU=Uah{ho|ympJ6?7`>>r!>1RJ#1j_eUWN9Z$!(UbYpaXZqkmwx2e ztLa#60|jJc!1m+=!A7kHwzGTRu7tNTG5_yQ2$z`O2v;QLqm}T+D)Tt{t{YzIQ&;hZ zTn=2NQ!CwD_~$L=Zcx4mToZhr3v1})Tb6$EYft_P^Ji{aaDh*QD`27x=g}3Of{y$! z@F`)lv`e629iYcjzvJR@?1d1xo3T9vN`>)eSrOBL!`N|SSv|8~r_2;7 z7-0^dsQ!?X!ZPmDYlXgT%wGrbEW>0UT`Tos?eP!jvZA*J*4uu1j>1Oj(*u0| z7u{OJHl>&V7-5q#lwcGC7z+XW!ZI^QB4qFd3s(3tj8p^M^7`>9z1)rUnG&pCeD(N8 w49fNwnBVU9!uEUN$h+@6Id%Nxh(^@$31+)aGPx5qPsJ2s;1NPU2YuY8ERv`;NFDmq4(S$ zOJNzxB9z?9bt1#n_2Y)nms}@^d-si@9!VaG(K@;F;RkVn?`D)RlpfxNoLOab(R?saLP>2qoK`Djx`_?Bjs`MJn(TN2?YAgK^f&TFX@<;kd_Vq* z(oiP-b}YtsyOjEB=An>1HIWR}e@ooPZYVG??2&;0ha9qx0%E5)I3T@9YMx?=lp~Z= eN`;gf>M7-zlvA9os?X6_#S2^#fjmNI4$WWna=e)U literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/dao/AccountDaoImpl.class b/AccountAssignment02/bin/com/demo/dao/AccountDaoImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..53aa1cc29e5751c3210b20c8ed336b947683268b GIT binary patch literal 2171 zcmaJ?T~pjt7=F%fK9(h=K)cWnXenCVWlL9)q85+>TWl0)Efr5SUW&>0=;y???Re}*GI=Onv8WgTXdlaup4&+|U-`-VUM`Q-(Gajcoh2wZf- z?Mltt4l6Y$tjxM@xEsV(C$zVB>LxUS?uX7Jr&4!<&C1>Nhn^doFa-MBgbC!F1fwBv z?z6?#v31W0n(&hXy5bQKHY29ox*z!Qdji>FX;na*4{M%@(*lJP<2xYGW5GmDuFhEK zKwjYVq91t6yW8tt^uSrKdjh?Sq3hIFoyeEZ>83HIxbn#2oP|DE11{_OI=8&Zgw5iPr>Th^X3Tb{9|jE* zuLzV|)_BbqO@Eiec!6cCwIcH9!c_~e;dMH{>BW+aR@*t0=-<2(1Ytb1;Rm&$w0L<8 zqb%LI#u^kC4_ja*j{IPAQf8R(iIVeUFLL5AqCG3I<9@N^>?osI9B$RTov`7@v)i(( z*lg__tCnmN;{v4~wBCoMqrwLtg z8pJj~`2=y105{2T~bu{Ev(=H#S%?LXlzMoXyEOs=eAny60Od!gu9XJE%hoOer>`)={C=cK~F7VC<#Q?98eu)Gb-g};+`zdY)qPaZuK@d!pcIhd7{nz)3S7nz-(4Z3#;0LL@)t==?#yJTNwap-crl@8C$t|h zblxavW6J|1{T|(;`*`)@x6ns_dYloDHBrzC`gaF^{)*wX-r{qN{7#6hvSnBqIzXa9 z3cAF<%bfZl6y-c~?*^_anIjZI+Lp{2jIsorX-wlfR~bg1RnoJl@Z==41Lk6y5Q51F z6K?2FIUnbS)NZ+* literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/exception/AccountNotFoundException.class b/AccountAssignment02/bin/com/demo/exception/AccountNotFoundException.class new file mode 100644 index 0000000000000000000000000000000000000000..117b10eec9a718b19628c3c3c6e9130e93256482 GIT binary patch literal 398 zcmb7AJx{|h5Pg@X34}tS2sQ>bpaL)5iYg&Qr>IL&ch|9kQDURiLHsQyBnEx}KMHXP zUjt%5mhSxSp5MLm>)Z1SfDr~U0>V(aQe?VxLO&>d=Z&-CLMc~UKXZP{IlKC5#0Uwy zxAIHwe+WvBpmbdq?RHVeTtq^YQV55MH`WC+J|khb|&QKQ&g*>T;>8Yq=~m zVURi{i-oLAgFlO*zcDMqY5EVJV?w7~<&EMmFN9?7>PqRUX=Wb$wd+~)5{FAUYX7VeOG`0TPZ$TkW>Y4aWN)EcCF+i22w;zt!4i6kz8au+CyG literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/exception/InsufficientBalanceException.class b/AccountAssignment02/bin/com/demo/exception/InsufficientBalanceException.class new file mode 100644 index 0000000000000000000000000000000000000000..641b5ff754b580e24be9e926444c80cd08f8329e GIT binary patch literal 410 zcmb7AO-sZu6r9)Xwpv$LSM(@aLB=C}XGjB4<>)Z1SfD;U21O%a6A?CVpLNArR_r_UqWvhCzFv@7_&txvG(idN3 zjF7N>Cm*C>A`{;PAv!hI_%UH;FZ~frd}(Yp+Mg1_b2rxsI#}(Yi-^!qjn&t6G1KLZ zoaLG@NS%`TRF6o{xj={&?%~{as8EtkW5@%Dt&31dxw9$`KX!35NyXk y2i~d4&oyQ=M!*Y*4i2BN^2nzE3D>0Uc3b5d#->Qwx#PDl*=0DctW zC43DqAWP4_^ZDLAzrH=c064`UMnD*5&WKzYC)8u69=vu|T-&8Ab$)JKZT;mJ9U~;{ z-pi#FrL=|kz92+r+G;-`>>Z^)f~l{xEylwcA-r(8O3=Z24_!oreyXjysm)wfw{l)8 z!XR~-EN8OP4gMrUf2S9OQTp$cV?xI)ipK9(5<)U{b(N_r-E=(od(M;Q9S*@p{7>MW vn#^2dMiT_QfarMigtZl)0wi3MmhHC64aWN)D)g|)i1pY)zxCQ?6kz8acb8x5 literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/service/AccountService.class b/AccountAssignment02/bin/com/demo/service/AccountService.class new file mode 100644 index 0000000000000000000000000000000000000000..210f3d360c8168157ade5ef4d1dbe3b59364a1f4 GIT binary patch literal 598 zcmZvZ%}&BV6oto+9<_Vs`X^Wn41w-ZOJwcf; zh&hfJ?sA0A9x~2LX#3Rd=N%kX25(P;2;${vWR%f??Mkw)bl${J_4Oi*jm^B2$crmD z8Vv4U*hp9f#HC11ULm$f`cR|jziMRq&g^|f@9KZIN8$b iq@B|Hrmje5g_I`Fc9e5m>?oJGN|lsOw`-bJK!i8 zgtoD2V{NL|YBjA^ZBG42)o5B$;UMSeZ~Wl@;Q!zs;ITgMJG;X|AnrL~_Wii`KKHrL zy|ek}fB*J(0LSsE2A_gMsa!UZHnX`z(JU-lDKjyYO65wnGvzLm*?dNWs-WSrv1lYR zhCQE{n7wSK91TGQ2mX(_0$(wu;E_>jU2?2UVk%|WwpkcZ;4h}<6tuf%j(N>VOj!(P zju?)4Hdn|R4ljib7te^1QxF;T;-!sT1uBntF?2GOv24pZMaSK-X$9)(T-wyosG#wI z=rwo*EgG7)$u7QF_b!Z4_IG~_SV%ag<5IUJ}I-M9BODypd#(o?UaSjtn*}W_Paai{Jfa|+U zM-9RX_KaG#IbO=nnuYVmY{pd3G@45pnQ5b7iM8Ae!;iRdS+Ai-L39^7Mb*PNinsuu z&`}GWd^!tOQNfYT8tg6^)}xVyGxJVaPOPcHu_1D+uI`LXqV=yi>_tq_UBO<$wk%eY1>` z(kWw+@+cD@!t+$AyA{TBxG1XsRRw)Jcu$UOcmE(Uv1tuoW7m4hks(i)3I)@y6gz|$ zm~we9j7zv!i&>;Ka1`wG47YZ$4ilUPbt$%(W0t`S#q6S&*mM{RxU9ia(7M@ElY+Z5 z*M#z{oUP*u>RCrw{3*vsT{&McQslOl;uKTv{8FAPCCR#Qhv;^RCd5LqiJp?Ns-?nI zXI+KR6IJ8Si_zgv=PomyG?ST_dnU&zVb62gY$uo|^xEcb%c-z612$5f1U_cuWe00` zg{|R{SlvS!zPWXt$uXhfTMFtWYEL%o&Z21)QVV6ChnJFRO4{SCsNsf!qh1uVLTII3 z$8*kE@|X53M1fz|@ohXIMkk%sU$vZtbiueflodo%gWbuIWGt!S`y44dcuv~I(%hVt zvZ$kS$9dkvco{#`@s?<%;JoRuzeK>db-aNeQ;fTbL9DoClgZeKF#ffU_wm6)jCn8k zkAL$`&5web)B@kUCi9j=(o0f!`JIjr@%x7mz>Ay@LEF44P3xV4VHfAjLWKd1fCLA^ z*`IWLgu4%cG$MS3in&rDWeUB79HYSO#Mc^kmvUmXf>|tOSn(S7TyBP^q}f?ZyqNZt zWmokZ`1FalkX(mQhkD-H!__I?6rZ+rG|VicX%(&a z(Y}uTGff?02> zZF;De(IQZ3wFgn@MW;1w@Hsrrr-IMp3D=);i}-7}_qH;&jN?sDt)PDy?JF1@7t7O? z<(WQJtdo`Xxf4OLo~Wz``?X~piD)bMN`EM--p0OlJU7$Z5^Pl?p{5I~m>Ii+NHlO8 z&Fi@29ejNiFOJ1O#j&0>7(U!VxIYvLtzf?AW8xda4SbIS)GwJCCo4b)`ROD}2hoT_ zh~O|+M-W37GkXku%ytNIoa66;N%X)#FVZ*$3kkf$8#kEwP3Ha?a&s^9LKcug zmXUqDVI#+9BVI)w-ynugt_vuV*T?Y!9Nr5u)&xpC)fll4i?~WQZ&Df8u*7dK5$_48 zpAiCoS1F2ymo;4X^LbsPTeN&ev1r>)z~hA=F>p*V{&(m@sN=F!hzcYkv_PW=+#A->TNKD}{y2&%)Hpu5|cvCulkD!Cx>)CYNABY4t&>jh_ z;0G;8HL#U38@sR z^hhdI+IC3F1Cq87l>Z=3!ie}C{B#TApGm~m8B=(V#-l5Ew_lB@8*B;zQSDyCdnzud z+X0?qokkgGjJlbS0OJyP)B_mx07lCI`TJYKQa52mTv+epmt|O+^?8Ma2rAknsPWzn z>=BT9+t=_bKkhZ-_C20flQvD-FHq0Vvt$>mFtvG@+B{5ck}4l9TulB=OnY5SAL2I; zV7gT%s;i2qXhdaI+bcy?+aF!SZ&j$(McpgueUY3QXyNERh!nfctSW4mhq24U*j2^| zcH|vO&QJRT+ZjCUqWuVe*iu+mivMC1OXuc1yKh8n* zu9z4bWp##HDb7D`OQcJ>yFwrt7C(!2!a2xhj$X1Nn%kv`#`I|ihl`5yqG=Ve;@aQ}aa CU`Nvc literal 0 HcmV?d00001 diff --git a/AccountAssignment02/bin/com/demo/test/TestAccountInheritance.class b/AccountAssignment02/bin/com/demo/test/TestAccountInheritance.class new file mode 100644 index 0000000000000000000000000000000000000000..f91f802ecfaf6d1b794cc3b170e943f98538fb58 GIT binary patch literal 4289 zcma)9Yj9N69siw^$Gyq!@(K&#y~x9aNFuLDg7V5k7YSe!o)(&$-5YYrzPfui5K$|> z5h|!urL{#{E3H~ASiwleTI`2*I>QG$)9DAMtdIRe04&8XG)RHDkz~9fYQ~cdwwbXTy7;vw5=mwgb~w>zrY+k@L`)5( z0^{}=14cv4NbGLd*t5rs*aGD@TM5fvDNs^VyG5Y1B^fmSb$6zm~O?LI3bFn|63W6KKai5pfzU{cMU>kBq@+G#7XdqwRQ z4dVso&%L(-!9Pzz<-W+-9q4H<5RDlre&YnU%kqA{>Ba!Jf z)1lsMBC2DNKwue->|=eHp_G--v4o6`3S~z6Lp=u7Mob;c7?YdoL#DlB(rVa-z|@*>ZJ~5~ zOe2viwiP;lieP{he#RHf~9m7VpYa^kiXOIXJSfeP2+aI{&+CWg{;ppVIL5~Sku zB|kdRB~Yp2)0)gWJ;o5V>R>+x3P+d_PU-@mm6Mx3ywISr>=`Lkb{&EGf~hu zVsMepWKlrc%w%KqN17bm3k%#|-1;;~P|u=bXFji=m5=69j+x>Ii?tz-=x*bM>9p>) znA%E{mryw?*eO+ME>JJ{02-$C`NZZR8-4xdnf zEMm@A8!;jiqCn%1Row z881^gbsgoGvQ6jbMt=JF`3+Im^YaSn%ATG499C*?_Qb99*43WaMy)QW4PmWBv#$7V zbLms`vsiah)+kg*j&e1CBf~D1E!HOYlEkk2vuu`57e^nfJlH;WK zeY20i6yI6wbl^*QIO4$XDAwMbuu+N}(L?AfrC`MubB-L&i*QBWore<+J*HT{niHwi zPsrpTzk;$ks6s&nzv_a%pg&kqT{eWh<(@AXqj>f^f~(Z_9%rjJ2MA0Fcy8g7JnXoI z4;Aak_+I_PYVH7i@DjLGSI@LC;(tdMpd zhqh1n`Z*kNGz{U15}d_1&f>Tut$mcVMkVdJoK-3jJT`>yNFG{u5|c-wYA~Me&jN2Vu1iBPyF@w~SzyJR(oY(_Amf z%kmFAUjnwCcnm!(>G3S^D*jJI5Y?E$=leWN#X?NOGEB!U#I#{1Ixq{H+1opC9d=?4 zx-l0K%*Qc4)Sg2vUc>^tiaMOZ4frWfzlVDKnmvCBi||`4#$_zQpZT-uZRK}t3uEpJ6ecEFaKk(Jx9S9W7inz&1* zaIehZKDi$U^B|N%>D4 zlmEuk@;`W1jX%a*Up_@UUc~}PT~g~K~?fY{17j5o(AP#@CxHxf}Qdi{D`|! zbjxEnh1WP~Bk~FSm^h6YsKROHLT8*;;dSCF7>yn7j(*+d?T#=rE|otE@e}e@GRi)0 z_de}$aP;2W(MBKMV6FO?DId<^P442{4LP`b9Nb&P9mfF9Q=X66=%YQa!q0g7@HY7Z zjJSI?z}Pn90;vH;(}#CR9mBZ!@H1!kfx|}}-gV*=yn>*H77bP63g2xdqIsCU@K@^3 zJuFcS7%OYnMh($n-Wl3RBGN7`Id&M^;2%j8`~!yB9HR*!;q#;_GXkT9(PUTJXbQ9I diYsQ|Fng}3N5z 0) { + this.balance = this.balance + amount; + } + else { + throw new InvalidAmountException("Enter valid amount"); + } + + } + + //To withdraw amount from an account + public abstract int withdraw(double amount) throws InsufficientBalanceException; + + //To calculate interest + public abstract double calculateInterest(); + +} diff --git a/AccountAssignment02/src/com/demo/bean/CurrentAccount.java b/AccountAssignment02/src/com/demo/bean/CurrentAccount.java new file mode 100644 index 00000000..6a29bebc --- /dev/null +++ b/AccountAssignment02/src/com/demo/bean/CurrentAccount.java @@ -0,0 +1,42 @@ +package com.demo.bean; + +import java.util.Date; + +import com.demo.exception.InsufficientBalanceException; + +public class CurrentAccount extends Account{ + private int noOfTransactions; + private static final int interestRate; + static { + interestRate = 0; + } + //Default constructor + public CurrentAccount(){ + noOfTransactions = 3; + } + + //Parameterized constructor + public CurrentAccount(String name, int pin, double balance, Date dateOfJoining, String accountType) { + super(name, pin, balance, dateOfJoining, accountType); + } + + //Display object + @Override + public String toString() { + return super.toString() + "\nNo of Transactions : " + noOfTransactions + "\nInterest :" + this.calculateInterest(); + } + + @Override + public int withdraw(double amount) throws InsufficientBalanceException { + if(this.getBalance() - amount >= 0) { + this.setBalance(this.getBalance() - amount); + return 1; + } + throw new InsufficientBalanceException("Insufficient balance in your account"); + } + + @Override + public double calculateInterest() { + return this.getBalance() * interestRate /100; + } +} diff --git a/AccountAssignment02/src/com/demo/bean/SavingAccount.java b/AccountAssignment02/src/com/demo/bean/SavingAccount.java new file mode 100644 index 00000000..b3006bba --- /dev/null +++ b/AccountAssignment02/src/com/demo/bean/SavingAccount.java @@ -0,0 +1,50 @@ +package com.demo.bean; + +import java.util.Date; + +import com.demo.exception.InsufficientBalanceException; + +public class SavingAccount extends Account{ + private String chequeBookNo; + private static final int interestRate; + + static { + interestRate = 4; + } + + //Default constructor + public SavingAccount() { + chequeBookNo = null; + } + + //Parameterized constructor + public SavingAccount(String name, int pin, double balance, Date dateOfJoining, String accountType) { + super(name, pin, balance, dateOfJoining, accountType); + this.chequeBookNo = pin+"-"+super.getId(); + } + + //Display object + @Override + public String toString() { + return super.toString() + "\nCheque Book No : " + chequeBookNo + "\nInterest :" + this.calculateInterest(); + } + + @Override + public int withdraw(double amount) throws InsufficientBalanceException { + if(this.getBalance() - amount >= 10000) { + this.setBalance(this.getBalance() - amount); + return 1; + } + throw new InsufficientBalanceException("Insufficient balance in your account"); + } + + @Override + public double calculateInterest() { + if(this.getBalance() > 50000) { + return this.getBalance() * interestRate/100 + 2 / this.getBalance(); + } + + return this.getBalance() * interestRate / 100; + } + +} diff --git a/AccountAssignment02/src/com/demo/dao/AccountDao.java b/AccountAssignment02/src/com/demo/dao/AccountDao.java new file mode 100644 index 00000000..308e6b85 --- /dev/null +++ b/AccountAssignment02/src/com/demo/dao/AccountDao.java @@ -0,0 +1,18 @@ +package com.demo.dao; + +import com.demo.bean.Account; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public interface AccountDao { + + void createAccount(Account acc); + Account searchAccountById(int id) throws AccountNotFoundException; + int depositAmount(Account acc, double amount) throws InvalidAmountException; + int withdrawAmount(Account acc, double amount, int pin) throws InsufficientBalanceException; + void transferAmount(Account targetAcc, double amount); + void changePin(Account acc, int pin, int newPin); + double getBalance(Account acc, int pin); + +} diff --git a/AccountAssignment02/src/com/demo/dao/AccountDaoImpl.java b/AccountAssignment02/src/com/demo/dao/AccountDaoImpl.java new file mode 100644 index 00000000..5cff6bba --- /dev/null +++ b/AccountAssignment02/src/com/demo/dao/AccountDaoImpl.java @@ -0,0 +1,76 @@ +package com.demo.dao; + +import com.demo.bean.Account; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; +import com.demo.service.AccountServiceImpl; + +public class AccountDaoImpl implements AccountDao { + static Account[] accounts; + static int count; + + static { + accounts = new Account[3]; + count = 0; + } + + //Create an account + @Override + public void createAccount(Account acc) { + accounts[count] = acc; + count = count + 1; + } + + //Search an account by Id + @Override + public Account searchAccountById(int id) throws AccountNotFoundException{ + int iterator = 0; + for(Account acc : accounts) { + if(iterator < count) { + if(acc.getId() == id) { + return acc; + } + iterator++; + } + } + throw new AccountNotFoundException("Cannot find account"); + } + + //Deposit amount into an account + @Override + public int depositAmount(Account acc, double amount) throws InvalidAmountException { + acc.deposit(amount); + return 1; + } + + //Withdraw amount from an account + @Override + public int withdrawAmount(Account acc, double amount, int pin) throws InsufficientBalanceException { + int result = acc.withdraw(amount); + if(result != -1) { + return 1; + } + return -1; + } + + //Transfer amount to other account + @Override + public void transferAmount(Account targetAcc, double amount) { + targetAcc.setBalance(targetAcc.getBalance() + amount); + } + + //Change the pin of an account + @Override + public void changePin(Account acc, int pin, int newPin) { + acc.setPin(newPin); + } + + //Get the balance of an account + @Override + public double getBalance(Account acc, int pin) { + return acc.getBalance(); + } + + +} diff --git a/AccountAssignment02/src/com/demo/exception/AccountNotFoundException.java b/AccountAssignment02/src/com/demo/exception/AccountNotFoundException.java new file mode 100644 index 00000000..9c564678 --- /dev/null +++ b/AccountAssignment02/src/com/demo/exception/AccountNotFoundException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class AccountNotFoundException extends Exception{ + public AccountNotFoundException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment02/src/com/demo/exception/InsufficientBalanceException.java b/AccountAssignment02/src/com/demo/exception/InsufficientBalanceException.java new file mode 100644 index 00000000..06ba22f9 --- /dev/null +++ b/AccountAssignment02/src/com/demo/exception/InsufficientBalanceException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class InsufficientBalanceException extends Exception{ + public InsufficientBalanceException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment02/src/com/demo/exception/InvalidAmountException.java b/AccountAssignment02/src/com/demo/exception/InvalidAmountException.java new file mode 100644 index 00000000..082a7c3d --- /dev/null +++ b/AccountAssignment02/src/com/demo/exception/InvalidAmountException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class InvalidAmountException extends Exception{ + public InvalidAmountException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment02/src/com/demo/service/AccountService.java b/AccountAssignment02/src/com/demo/service/AccountService.java new file mode 100644 index 00000000..89584b85 --- /dev/null +++ b/AccountAssignment02/src/com/demo/service/AccountService.java @@ -0,0 +1,17 @@ +package com.demo.service; + +import com.demo.bean.Account; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public interface AccountService { + Account acceptAccountData(int accountType); + int withdrawAmount(int id, double amount, int pin) throws AccountNotFoundException, InsufficientBalanceException; + int depositAmount(int id, double amount) throws AccountNotFoundException, InvalidAmountException; + Account searchAccountById(int id) throws AccountNotFoundException; + double getBalance(int id, int pin) throws AccountNotFoundException; + int changePin(int id, int pin, int newPin) throws AccountNotFoundException; + int transferAmount(int sourceId, int targetId, int pin, double amount) throws AccountNotFoundException, InsufficientBalanceException; + +} diff --git a/AccountAssignment02/src/com/demo/service/AccountServiceImpl.java b/AccountAssignment02/src/com/demo/service/AccountServiceImpl.java new file mode 100644 index 00000000..e3f6e405 --- /dev/null +++ b/AccountAssignment02/src/com/demo/service/AccountServiceImpl.java @@ -0,0 +1,124 @@ +package com.demo.service; +import java.text.ParseException; +import java.math.*; +import java.lang.*; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Scanner; + +import com.demo.bean.Account; +import com.demo.bean.CurrentAccount; +import com.demo.bean.SavingAccount; +import com.demo.dao.AccountDao; +import com.demo.dao.AccountDaoImpl; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public class AccountServiceImpl implements AccountService{ + public static Scanner sc = new Scanner(System.in); + public static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); + + private AccountDao accountDao; + + //Default constructor + public AccountServiceImpl(){ + this.accountDao = new AccountDaoImpl(); + } + + //Accept user data and create accounts + @Override + public Account acceptAccountData(int accountType) { + Account acc = null; + System.out.println("Enter Name :"); + String name = sc.next(); + System.out.println("Enter Balance :"); + double balance = sc.nextDouble(); + System.out.println("Enter Pin :"); + int pin = sc.nextInt(); + System.out.println("Enter Date :"); + String doj= sc.next(); + try { + Date dateOfJoining = sdf.parse(doj); + if(accountType == 1) { + acc = new SavingAccount(name, pin, balance, dateOfJoining, "Saving"); + } + else if(accountType == 2) { + acc = new CurrentAccount(name, pin, balance, dateOfJoining, "Current"); + } + accountDao.createAccount(acc); + } catch (ParseException e) { + e.printStackTrace(); + } + return acc; + } + + //Display account data to user + @Override + public Account searchAccountById(int id) throws AccountNotFoundException{ + return accountDao.searchAccountById(id); + } + + //Withdraw amount + @Override + public int withdrawAmount(int id, double amount, int pin) throws AccountNotFoundException, InsufficientBalanceException { + Account acc = accountDao.searchAccountById(id); + if(acc != null && acc.getPin() == pin) { + return accountDao.withdrawAmount(acc, amount, pin); + } + return -1; + } + + //Deposit amount + @Override + public int depositAmount(int id, double amount) throws AccountNotFoundException, InvalidAmountException { + Account acc = searchAccountById(id); + if(acc != null) { + accountDao.depositAmount(acc, amount); + } + return 1; + + } + + //Get the balance of an account + @Override + public double getBalance(int id, int pin) throws AccountNotFoundException { + Account acc = searchAccountById(id); + if(acc != null) { + return accountDao.getBalance(acc, pin); + } + return -1; + } + + //Change pin of a account + @Override + public int changePin(int id, int pin, int newPin) throws AccountNotFoundException { + Account acc = searchAccountById(id); + if(acc != null && acc.getPin() == pin) { + accountDao.changePin(acc, pin, newPin); + return 1; + } + return -1; + } + + //Transfer amount to other account + @Override + public int transferAmount(int sourceId, int targetId, int pin, double amount) throws AccountNotFoundException, InsufficientBalanceException { + Account sourceAcc =searchAccountById(sourceId); + if(sourceAcc != null) { + int result = accountDao.withdrawAmount(sourceAcc, amount, pin); + if(result != -1) { + Account targetAcc = searchAccountById(targetId); + if(targetAcc != null) { + accountDao.transferAmount(targetAcc, amount); + return 1; + } + } + } + return -1; + } + + + + +} diff --git a/AccountAssignment02/src/com/demo/test/TestAccountInheritance.java b/AccountAssignment02/src/com/demo/test/TestAccountInheritance.java new file mode 100644 index 00000000..ff6c6cd9 --- /dev/null +++ b/AccountAssignment02/src/com/demo/test/TestAccountInheritance.java @@ -0,0 +1,153 @@ +package com.demo.test; + +import java.util.Date; +import java.util.Scanner; + +import com.demo.bean.Account; +import com.demo.bean.SavingAccount; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; +import com.demo.service.AccountService; +import com.demo.service.AccountServiceImpl; + +public class TestAccountInheritance { + + public static void main(String[] args) { + AccountService accountService = new AccountServiceImpl(); + + Scanner sc = new Scanner(System.in); + int choice = 0; + + //Menu to be displayed + do { + System.out.println("1. Create new account"); + System.out.println("2. Withdraw amount"); + System.out.println("3. Make a deposit"); + System.out.println("4. Transfer fund"); + System.out.println("5. Change pin"); + System.out.println("6. Check balance"); + System.out.println("7. Display account by Id"); + System.out.println("8. Exit"); + + choice = sc.nextInt(); + int id = 0; + double amount = 0; + int accountType = 0; + + switch(choice) { + case 1: + System.out.println("1. Saving Account"); + System.out.println("2. Current Account"); + System.out.println("Enter type of account"); + accountType = sc.nextInt(); + Account acc = accountService.acceptAccountData(accountType); + System.out.println("Account created"); + System.out.println(acc); + break; + case 2: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + System.out.println("Enter the pin"); + int pin = sc.nextInt(); + int result; + try { + result = accountService.withdrawAmount(id, amount, pin); + if(result != -1) { + System.out.println("Successful withdrawal"); + } + } catch (AccountNotFoundException e5) { + System.out.println(e5.getMessage()); + } catch (InsufficientBalanceException e) { + System.out.println(e.getMessage()); + } + break; + case 3: + System.out.println("Enter Id"); + id = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + try { + result = accountService.depositAmount(id, amount); + System.out.println("Deposit Successful"); + } catch (AccountNotFoundException e4) { + System.out.println(e4.getMessage()); + } catch (InvalidAmountException e) { + System.out.println(e.getMessage()); + } + + break; + case 4: + System.out.println("Enter Id of source account:"); + int sourceId = sc.nextInt(); + System.out.println("Enter Id of target account"); + int targetId = sc.nextInt(); + System.out.println("Enter the pin of source account"); + pin = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + try { + result = accountService.transferAmount(sourceId, targetId, pin, amount); + if(result != -1) { + System.out.println("Transfer Successful"); + } + else { + System.out.println("Transfer failed"); + } + } catch (AccountNotFoundException e3) { + System.out.println(e3.getMessage()); + } catch (InsufficientBalanceException e) { + System.out.println(e.getMessage()); + } + + break; + case 5: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the current pin"); + pin = sc.nextInt(); + System.out.println("Enter the new pin"); + int newPin = sc.nextInt(); + try { + result = accountService.changePin(id, pin, newPin); + if(result != -1) { + System.out.println("Pin changed"); + } + else { + System.out.println("Cannot change pin"); + } + } catch (AccountNotFoundException e2) { + System.out.println(e2.getMessage()); + } + + + break; + case 6: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the pin"); + pin = sc.nextInt(); + try { + System.out.println("Account balance is :" + accountService.getBalance(id, pin)); + } catch (AccountNotFoundException e1) { + System.out.println(e1.getMessage()); + } + break; + case 7: + System.out.println("Enter Id :"); + id = sc.nextInt(); + try { + System.out.println(accountService.searchAccountById(id)); + } catch (AccountNotFoundException e) { + System.out.println(e.getMessage()); + } + break; + case 8: + System.exit(0); + } + }while(choice != 8); + + } +} From 345e0590c927f2a3ac52fc7893bee6ba2f89b5bd Mon Sep 17 00:00:00 2001 From: abhijeet Date: Tue, 22 Sep 2020 16:15:12 +0530 Subject: [PATCH 3/6] Assignment 3 for evaluation --- AccountAssignment03/.classpath | 6 + AccountAssignment03/.project | 17 ++ .../.settings/org.eclipse.jdt.core.prefs | 12 ++ .../bin/com/demo/bean/Account.class | Bin 0 -> 3632 bytes .../bin/com/demo/bean/CurrentAccount.class | Bin 0 -> 1900 bytes .../bin/com/demo/bean/SavingAccount.class | Bin 0 -> 2065 bytes .../bin/com/demo/dao/AccountDao.class | Bin 0 -> 683 bytes .../bin/com/demo/dao/AccountDaoImpl.class | Bin 0 -> 2396 bytes .../exception/AccountNotFoundException.class | Bin 0 -> 398 bytes .../InsufficientBalanceException.class | Bin 0 -> 410 bytes .../exception/InvalidAmountException.class | Bin 0 -> 392 bytes .../bin/com/demo/service/AccountService.class | Bin 0 -> 598 bytes .../com/demo/service/AccountServiceImpl.class | Bin 0 -> 3813 bytes .../demo/test/TestAccountInheritance.class | Bin 0 -> 4289 bytes .../src/com/demo/bean/Account.java | 149 +++++++++++++++++ .../src/com/demo/bean/CurrentAccount.java | 51 ++++++ .../src/com/demo/bean/SavingAccount.java | 58 +++++++ .../src/com/demo/dao/AccountDao.java | 18 +++ .../src/com/demo/dao/AccountDaoImpl.java | 85 ++++++++++ .../exception/AccountNotFoundException.java | 7 + .../InsufficientBalanceException.java | 7 + .../exception/InvalidAmountException.java | 7 + .../src/com/demo/service/AccountService.java | 17 ++ .../com/demo/service/AccountServiceImpl.java | 124 ++++++++++++++ .../com/demo/test/TestAccountInheritance.java | 153 ++++++++++++++++++ 25 files changed, 711 insertions(+) create mode 100644 AccountAssignment03/.classpath create mode 100644 AccountAssignment03/.project create mode 100644 AccountAssignment03/.settings/org.eclipse.jdt.core.prefs create mode 100644 AccountAssignment03/bin/com/demo/bean/Account.class create mode 100644 AccountAssignment03/bin/com/demo/bean/CurrentAccount.class create mode 100644 AccountAssignment03/bin/com/demo/bean/SavingAccount.class create mode 100644 AccountAssignment03/bin/com/demo/dao/AccountDao.class create mode 100644 AccountAssignment03/bin/com/demo/dao/AccountDaoImpl.class create mode 100644 AccountAssignment03/bin/com/demo/exception/AccountNotFoundException.class create mode 100644 AccountAssignment03/bin/com/demo/exception/InsufficientBalanceException.class create mode 100644 AccountAssignment03/bin/com/demo/exception/InvalidAmountException.class create mode 100644 AccountAssignment03/bin/com/demo/service/AccountService.class create mode 100644 AccountAssignment03/bin/com/demo/service/AccountServiceImpl.class create mode 100644 AccountAssignment03/bin/com/demo/test/TestAccountInheritance.class create mode 100644 AccountAssignment03/src/com/demo/bean/Account.java create mode 100644 AccountAssignment03/src/com/demo/bean/CurrentAccount.java create mode 100644 AccountAssignment03/src/com/demo/bean/SavingAccount.java create mode 100644 AccountAssignment03/src/com/demo/dao/AccountDao.java create mode 100644 AccountAssignment03/src/com/demo/dao/AccountDaoImpl.java create mode 100644 AccountAssignment03/src/com/demo/exception/AccountNotFoundException.java create mode 100644 AccountAssignment03/src/com/demo/exception/InsufficientBalanceException.java create mode 100644 AccountAssignment03/src/com/demo/exception/InvalidAmountException.java create mode 100644 AccountAssignment03/src/com/demo/service/AccountService.java create mode 100644 AccountAssignment03/src/com/demo/service/AccountServiceImpl.java create mode 100644 AccountAssignment03/src/com/demo/test/TestAccountInheritance.java diff --git a/AccountAssignment03/.classpath b/AccountAssignment03/.classpath new file mode 100644 index 00000000..51a8bbad --- /dev/null +++ b/AccountAssignment03/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/AccountAssignment03/.project b/AccountAssignment03/.project new file mode 100644 index 00000000..1628b167 --- /dev/null +++ b/AccountAssignment03/.project @@ -0,0 +1,17 @@ + + + AccountAssignment03 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/AccountAssignment03/.settings/org.eclipse.jdt.core.prefs b/AccountAssignment03/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..ec1937b3 --- /dev/null +++ b/AccountAssignment03/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/AccountAssignment03/bin/com/demo/bean/Account.class b/AccountAssignment03/bin/com/demo/bean/Account.class new file mode 100644 index 0000000000000000000000000000000000000000..7e62da1a931bdbad7abba8446e4b1cc9a8ae3748 GIT binary patch literal 3632 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 literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/bean/SavingAccount.class b/AccountAssignment03/bin/com/demo/bean/SavingAccount.class new file mode 100644 index 0000000000000000000000000000000000000000..dca9a05bfa374eb33a1370f9a6d2dbfd29c48a50 GIT binary patch literal 2065 zcma)6-Bue_6#h;KlQ2xcrYV)5(gkj%tnLhTdi z8}!1ZPtdiht%feUmR@-0llT-a_dYWOLbxy&Ip@s&_Wr*8bI#xY{{9DmX*eMS1O^SK zoGzGUC!IHSJH4SFT6S^CFr2#Wh7c6E)C%xT0^KzUU16Yr$O&l1p7~APTy~s;HAf)2 zy00JV>5^_2(;IG;!e$6#*{)eNYwkncH3h=+M#-`*cR`>dk=zmpt~dp=3j#eFx}fmx z4Go=81bSC3+gz)c^JaBZ&zHzMy6PBuX-ltKeD*&o^D>}{4qVc35#1c)vW5`C6yDvl zY64eQTa#+ZnpECNv}@00y>E5bDy6feKGTj#ZZYi;(_RsnOXS)i|1V4kS4s5Q`YqS3 zQo*dMcnhN;j8JLLA~amXb%D^KUaFhxyVSizF4->^dq(|poU8fx8} z{LLp7ate|x+0hlQ)sjHKDsVcp+<_0c)*lMoI9-kP{Jv?pnRAqdai0cOU6EHL&UYlf z=EUdXVXP9Zn)9zkd`_itUDL3Rj|DE!cpLQ+$v(Er+GV+R54m<5T)S*L-Er-xVvj9% zuTa$=b2`~1T~qb$w}x49Eyu2f@R>lmc^AxMLpo>I>btv^VVSnO?A5U8#R5Oq@C6H0 zsiD4IS^VpJdRG9pf34vWbh6i)c8{M1%MiGBI)2=5QrxoRPn>!+?)N~&HpY1D%H9(b z*>H8^;DKI|7hPHWXJ67Oi#u|KvgoZuuWnEr!@Ot7SEA*1Px6(a_E8}T-a%^VaiLv+ z9|&3p_}QVAPb#_zr_t#at^Df>y+kDV61~6BA%F|?-y;J>5Tsogy@*N+$bsG--+i92 z96(JSA(j%qq3^7Jl>9Febxite9vW|=pS(EIfFJ2c;t0{VnbZsPjt?dKJNuO*45nUV zcxUJp;zzgXI*YfzXUsQiDfWK1o=WU$2s1Typk#s3xa^tc)c1 z%KNc4iH}vtJSn%kuW*l3&2g%~qK}s7N4#&~K?9#q+CLN8YY?jfuAeGw%I6Z;#HWPX zB72Zf+p^asQpU3}O2KxyT666*Pqi#&MZS z+K56WEoWqMx>O)9Ih5>_FxXOfgps#iu`EfVVFY`R*VF%ZcHD&yMlD h<@58V3~v~3)8I{G1hc1dp7JI5#3MvmCbt0W{{VL1rXBzQ literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/dao/AccountDao.class b/AccountAssignment03/bin/com/demo/dao/AccountDao.class new file mode 100644 index 0000000000000000000000000000000000000000..08955d7722f37f038dd23552fa98b75db3ad15ae GIT binary patch literal 683 zcmaKq&rSj{5XQeEvV!u@f2i;PZcN;ZH%|~G*~F-ciTBbiPy#L4EugRF!3Xf6jI+q% z9#}4&U2YuY8ERv`;NFDmq4(S$ zOJNzxB9z?9bt1#n_2Y)nms}@^d-si@9!VaG(K@;F;RkVn?`D)RlpfxNoLOab(R?saLP>2qoK`Djx`_?Bjs`MJn(TN2?YAgK^f&TFX@<;kd_Vq* z(oiP-b}YtsyOjEB=An>1HIWR}e@ooPZYVG??2&;0ha9qx0%E5)I3T@9YMx?=lp~Z= eN`;gf>M7-zlvA9os?X6_#S2^#fjmNI4$WWna=e)U literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/dao/AccountDaoImpl.class b/AccountAssignment03/bin/com/demo/dao/AccountDaoImpl.class new file mode 100644 index 0000000000000000000000000000000000000000..a7870ad6a4b749e2cdde07016d0df15f302d74e9 GIT binary patch literal 2396 zcmaJ>TTdHD7(L_Lf?4h%X)vUa^kQR*)0QM{Op*c)ts9dYDJki7STC@|tkHT+67|Pa z>PufD^%4oBBDHzyL!bJCqN-RW}X zy;Uz%WxX(KS@ovtmt?)Xwao(wfxb<-BMUX@t{3jCZrYY_ASH07O`1T53@{o3LlvFd z^qpE^*7M}Eiqr6m0-a0Fx-0#rXA4Z7bY`X!!LQoVJ&;wr&g7(4C?Lw@nz3q*>-g6N z;@RA?Kw`dLwGH$O44y!pMjr-EoI;O4YDOn^Lg2Is108Dhnu#u$0=*T-wQo1KR&DQr zT&+>&K&5WU+OqT<^{hA3h+~kH{)WR^M-L_c*GS6lwme(2@UzYs#rGguE0n{p)=;2 zo@cv$lyVVM%8zLimvC9YaNMf>^v+rvPs-}-2PQtmRl2io`|2F)JwC%l12YUAr4Bhe zz;PO!m#$m)$JWRZ&W?`Z0d+L~iIY}K6PSX%ZGF%L|926A^C&;@Gv%Eq@H zmzq4g(X7#g9^aF0W6kys^!$%2d@+jn(!^KzS|H8lhRg)b=1MB~tqG|-NHgV{Pyvv+pVmZ7VNxG!@#KiFGxrDWd6&lxsiHi?$-mIeMI4sy98$UU1aKF&Iu& zc%@FMNyIqsnmGTHh@nGWK3sS5QjQ_bHLoD9JGtsc4)l7+${q$@U?~0q zXMW*U3}^Y>LqK4F0E1kg!my5j>AdbjkOF@N_mdNQ$Q-7o^k%nCF@pmb!6*+3oWtw< zRtjcGq%?H?ilO{2#vUF5q;=pd1!pwK>EK`pqDpxKZxTk}ExgTGmM{rE5Kd6LbO?BilIn&(oO;7@~@EWIs>l34RK^kgj4%Yn})+M4C&OV;lHF^H-^l z@q8cVxfe%?$h`euVaPzSBg0cSvCvZ2$GWa^SeKE{?xLJ{&ZMAKfnC$={v}O4#)IG# z1fHu^V3%4g;x@Ac?%-|{kR!my<(D+LBB>k149ag#levkw7yXrfW>Q zp(zzP6C=w0h_XMVRMCg5Ho@F9KIbZ_>*lb$La*xO3Lf!Wjm9Els)Jp54#pQ*YZu=f zAC8*@S!k)YE28egsvZueN7Y)WhS2v}wSrFN*=zea>MasiTH2S2P*YJsDP4w|+!Qu+ p`vh+gC&Zs8zH&dQl>fv<(4yd#xYr^$89^r_=wt{ju&Fa2{|n=4-t+(f literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/exception/AccountNotFoundException.class b/AccountAssignment03/bin/com/demo/exception/AccountNotFoundException.class new file mode 100644 index 0000000000000000000000000000000000000000..117b10eec9a718b19628c3c3c6e9130e93256482 GIT binary patch literal 398 zcmb7AJx{|h5Pg@X34}tS2sQ>bpaL)5iYg&Qr>IL&ch|9kQDURiLHsQyBnEx}KMHXP zUjt%5mhSxSp5MLm>)Z1SfDr~U0>V(aQe?VxLO&>d=Z&-CLMc~UKXZP{IlKC5#0Uwy zxAIHwe+WvBpmbdq?RHVeTtq^YQV55MH`WC+J|khb|&QKQ&g*>T;>8Yq=~m zVURi{i-oLAgFlO*zcDMqY5EVJV?w7~<&EMmFN9?7>PqRUX=Wb$wd+~)5{FAUYX7VeOG`0TPZ$TkW>Y4aWN)EcCF+i22w;zt!4i6kz8au+CyG literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/exception/InsufficientBalanceException.class b/AccountAssignment03/bin/com/demo/exception/InsufficientBalanceException.class new file mode 100644 index 0000000000000000000000000000000000000000..641b5ff754b580e24be9e926444c80cd08f8329e GIT binary patch literal 410 zcmb7AO-sZu6r9)Xwpv$LSM(@aLB=C}XGjB4<>)Z1SfD;U21O%a6A?CVpLNArR_r_UqWvhCzFv@7_&txvG(idN3 zjF7N>Cm*C>A`{;PAv!hI_%UH;FZ~frd}(Yp+Mg1_b2rxsI#}(Yi-^!qjn&t6G1KLZ zoaLG@NS%`TRF6o{xj={&?%~{as8EtkW5@%Dt&31dxw9$`KX!35NyXk y2i~d4&oyQ=M!*Y*4i2BN^2nzE3D>0Uc3b5d#->Qwx#PDl*=0DctW zC43DqAWP4_^ZDLAzrH=c064`UMnD*5&WKzYC)8u69=vu|T-&8Ab$)JKZT;mJ9U~;{ z-pi#FrL=|kz92+r+G;-`>>Z^)f~l{xEylwcA-r(8O3=Z24_!oreyXjysm)wfw{l)8 z!XR~-EN8OP4gMrUf2S9OQTp$cV?xI)ipK9(5<)U{b(N_r-E=(od(M;Q9S*@p{7>MW vn#^2dMiT_QfarMigtZl)0wi3MmhHC64aWN)D)g|)i1pY)zxCQ?6kz8acb8x5 literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/service/AccountService.class b/AccountAssignment03/bin/com/demo/service/AccountService.class new file mode 100644 index 0000000000000000000000000000000000000000..210f3d360c8168157ade5ef4d1dbe3b59364a1f4 GIT binary patch literal 598 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 CU`Nvc literal 0 HcmV?d00001 diff --git a/AccountAssignment03/bin/com/demo/test/TestAccountInheritance.class b/AccountAssignment03/bin/com/demo/test/TestAccountInheritance.class new file mode 100644 index 0000000000000000000000000000000000000000..f91f802ecfaf6d1b794cc3b170e943f98538fb58 GIT binary patch literal 4289 zcma)9Yj9N69siw^$Gyq!@(K&#y~x9aNFuLDg7V5k7YSe!o)(&$-5YYrzPfui5K$|> z5h|!urL{#{E3H~ASiwleTI`2*I>QG$)9DAMtdIRe04&8XG)RHDkz~9fYQ~cdwwbXTy7;vw5=mwgb~w>zrY+k@L`)5( z0^{}=14cv4NbGLd*t5rs*aGD@TM5fvDNs^VyG5Y1B^fmSb$6zm~O?LI3bFn|63W6KKai5pfzU{cMU>kBq@+G#7XdqwRQ z4dVso&%L(-!9Pzz<-W+-9q4H<5RDlre&YnU%kqA{>Ba!Jf z)1lsMBC2DNKwue->|=eHp_G--v4o6`3S~z6Lp=u7Mob;c7?YdoL#DlB(rVa-z|@*>ZJ~5~ zOe2viwiP;lieP{he#RHf~9m7VpYa^kiXOIXJSfeP2+aI{&+CWg{;ppVIL5~Sku zB|kdRB~Yp2)0)gWJ;o5V>R>+x3P+d_PU-@mm6Mx3ywISr>=`Lkb{&EGf~hu zVsMepWKlrc%w%KqN17bm3k%#|-1;;~P|u=bXFji=m5=69j+x>Ii?tz-=x*bM>9p>) znA%E{mryw?*eO+ME>JJ{02-$C`NZZR8-4xdnf zEMm@A8!;jiqCn%1Row z881^gbsgoGvQ6jbMt=JF`3+Im^YaSn%ATG499C*?_Qb99*43WaMy)QW4PmWBv#$7V zbLms`vsiah)+kg*j&e1CBf~D1E!HOYlEkk2vuu`57e^nfJlH;WK zeY20i6yI6wbl^*QIO4$XDAwMbuu+N}(L?AfrC`MubB-L&i*QBWore<+J*HT{niHwi zPsrpTzk;$ks6s&nzv_a%pg&kqT{eWh<(@AXqj>f^f~(Z_9%rjJ2MA0Fcy8g7JnXoI z4;Aak_+I_PYVH7i@DjLGSI@LC;(tdMpd zhqh1n`Z*kNGz{U15}d_1&f>Tut$mcVMkVdJoK-3jJT`>yNFG{u5|c-wYA~Me&jN2Vu1iBPyF@w~SzyJR(oY(_Amf z%kmFAUjnwCcnm!(>G3S^D*jJI5Y?E$=leWN#X?NOGEB!U#I#{1Ixq{H+1opC9d=?4 zx-l0K%*Qc4)Sg2vUc>^tiaMOZ4frWfzlVDKnmvCBi||`4#$_zQpZT-uZRK}t3uEpJ6ecEFaKk(Jx9S9W7inz&1* zaIehZKDi$U^B|N%>D4 zlmEuk@;`W1jX%a*Up_@UUc~}PT~g~K~?fY{17j5o(AP#@CxHxf}Qdi{D`|! zbjxEnh1WP~Bk~FSm^h6YsKROHLT8*;;dSCF7>yn7j(*+d?T#=rE|otE@e}e@GRi)0 z_de}$aP;2W(MBKMV6FO?DId<^P442{4LP`b9Nb&P9mfF9Q=X66=%YQa!q0g7@HY7Z zjJSI?z}Pn90;vH;(}#CR9mBZ!@H1!kfx|}}-gV*=yn>*H77bP63g2xdqIsCU@K@^3 zJuFcS7%OYnMh($n-Wl3RBGN7`Id&M^;2%j8`~!yB9HR*!;q#;_GXkT9(PUTJXbQ9I diYsQ|Fng}3N5z>> 32)); + result = prime * result + ((dateOfJoining == null) ? 0 : dateOfJoining.hashCode()); + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + result = prime * result + pin; + return result; + } + + @Override + public boolean equals(Object obj) { + if(this.id == ((Account)obj).getId()) { + return true; + } + return false; + } + + //Display object + @Override + public String toString() { + return "Id : " + id + "\nName : " + name + "\nBalance : " + balance + "\nDate of Joining :" + dateOfJoining + "\nType of Account : " + accountType; + } + + //Setter and Getter Methods + public int getId() { + return id; + } + +// public void setId(int id) { +// this.id = id; +// } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getPin() { + return pin; + } + + public void setPin(int pin) { + this.pin = pin; + } + + public static int getInterestRate() { + return interestRate; + } + + public static void setInterestRate(int interestRate) { + Account.interestRate = interestRate; + } + + public double getBalance() { + return balance; + } + + public void setBalance(double balance) { + this.balance = balance; + } + + public Date getDateOfJoining() { + return dateOfJoining; + } + + public void setDateOfJoining(Date dateOfJoining) { + this.dateOfJoining = dateOfJoining; + } + + public String getAccountType() { + return accountType; + } + + public void setAccountType(String accountType) { + this.accountType = accountType; + } + + //To deposite amount in an account + public void deposit(double amount) throws InvalidAmountException { + if(amount > 0) { + this.balance = this.balance + amount; + } + else { + throw new InvalidAmountException("Enter valid amount"); + } + + } + + //To withdraw amount from an account + public abstract int withdraw(double amount) throws InsufficientBalanceException; + + //To calculate interest + public abstract double calculateInterest(); + +} diff --git a/AccountAssignment03/src/com/demo/bean/CurrentAccount.java b/AccountAssignment03/src/com/demo/bean/CurrentAccount.java new file mode 100644 index 00000000..55ccad76 --- /dev/null +++ b/AccountAssignment03/src/com/demo/bean/CurrentAccount.java @@ -0,0 +1,51 @@ +package com.demo.bean; + +import java.util.Date; + +import com.demo.exception.InsufficientBalanceException; + +public class CurrentAccount extends Account{ + private static int currentCount; + private int noOfTransactions; + private static final int interestRate; + + static { + interestRate = 0; + currentCount = 2000; + } + //Default constructor + public CurrentAccount(){ + noOfTransactions = 3; + } + + //Parameterized constructor + public CurrentAccount(String name, int pin, double balance, Date dateOfJoining, String accountType) { + super(currentCount, name, pin, balance, dateOfJoining, accountType); + this.currentCount++; + } + + //Constructor using fields + public CurrentAccount(int id) { + super(id); + } + + //Display object + @Override + public String toString() { + return super.toString() + "\nNo of Transactions : " + noOfTransactions + "\nInterest :" + this.calculateInterest(); + } + + @Override + public int withdraw(double amount) throws InsufficientBalanceException { + if(this.getBalance() - amount >= 0) { + this.setBalance(this.getBalance() - amount); + return 1; + } + throw new InsufficientBalanceException("Insufficient balance in your account"); + } + + @Override + public double calculateInterest() { + return this.getBalance() * interestRate /100; + } +} diff --git a/AccountAssignment03/src/com/demo/bean/SavingAccount.java b/AccountAssignment03/src/com/demo/bean/SavingAccount.java new file mode 100644 index 00000000..a6023121 --- /dev/null +++ b/AccountAssignment03/src/com/demo/bean/SavingAccount.java @@ -0,0 +1,58 @@ +package com.demo.bean; + +import java.util.Date; + +import com.demo.exception.InsufficientBalanceException; + +public class SavingAccount extends Account{ + private static int savingCount; + private String chequeBookNo; + private static final int interestRate; + + static { + interestRate = 4; + savingCount = 1; + } + + //Default constructor + public SavingAccount() { + chequeBookNo = null; + } + + //Parameterized constructor + public SavingAccount(String name, int pin, double balance, Date dateOfJoining, String accountType) { + super(savingCount, name, pin, balance, dateOfJoining, accountType); + this.chequeBookNo = pin+"-"+super.getId(); + this.savingCount++; + } + + //Constructor using fields + public SavingAccount(int id) { + super(id); + } + + //Display object + @Override + public String toString() { + return super.toString() + "\nCheque Book No : " + chequeBookNo + "\nInterest :" + this.calculateInterest(); + } + + @Override + public int withdraw(double amount) throws InsufficientBalanceException { + if(this.getBalance() - amount >= 10000) { + this.setBalance(this.getBalance() - amount); + return 1; + } + throw new InsufficientBalanceException("Insufficient balance in your account"); + } + + @Override + public double calculateInterest() { + if(this.getBalance() > 50000) { + return this.getBalance() * interestRate/100 + 2 / this.getBalance(); + } + + return this.getBalance() * interestRate / 100; + } + +} diff --git a/AccountAssignment03/src/com/demo/dao/AccountDao.java b/AccountAssignment03/src/com/demo/dao/AccountDao.java new file mode 100644 index 00000000..308e6b85 --- /dev/null +++ b/AccountAssignment03/src/com/demo/dao/AccountDao.java @@ -0,0 +1,18 @@ +package com.demo.dao; + +import com.demo.bean.Account; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public interface AccountDao { + + void createAccount(Account acc); + Account searchAccountById(int id) throws AccountNotFoundException; + int depositAmount(Account acc, double amount) throws InvalidAmountException; + int withdrawAmount(Account acc, double amount, int pin) throws InsufficientBalanceException; + void transferAmount(Account targetAcc, double amount); + void changePin(Account acc, int pin, int newPin); + double getBalance(Account acc, int pin); + +} diff --git a/AccountAssignment03/src/com/demo/dao/AccountDaoImpl.java b/AccountAssignment03/src/com/demo/dao/AccountDaoImpl.java new file mode 100644 index 00000000..0d79b18f --- /dev/null +++ b/AccountAssignment03/src/com/demo/dao/AccountDaoImpl.java @@ -0,0 +1,85 @@ +package com.demo.dao; + +import java.util.ArrayList; + +import com.demo.bean.Account; +import com.demo.bean.CurrentAccount; +import com.demo.bean.SavingAccount; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; +import com.demo.service.AccountServiceImpl; + +public class AccountDaoImpl implements AccountDao { + static ArrayList accounts; + static int count; + + static { + accounts = new ArrayList(); + count = 0; + } + + //Create an account + @Override + public void createAccount(Account acc) { + accounts.add(acc); +// count = count + 1; + } + + //Search an account by Id + @Override + public Account searchAccountById(int id) throws AccountNotFoundException{ + Account acc = null; + if(id < 2000) { + acc = new SavingAccount(id); + } + else { + acc = new CurrentAccount(id); + } + + if(acc != null) { + int pos = accounts.indexOf(acc); + if(pos != -1) { + return accounts.get(pos); + } + } + throw new AccountNotFoundException("Cannot find account"); + } + + //Deposit amount into an account + @Override + public int depositAmount(Account acc, double amount) throws InvalidAmountException { + acc.deposit(amount); + return 1; + } + + //Withdraw amount from an account + @Override + public int withdrawAmount(Account acc, double amount, int pin) throws InsufficientBalanceException { + int result = acc.withdraw(amount); + if(result != -1) { + return 1; + } + return -1; + } + + //Transfer amount to other account + @Override + public void transferAmount(Account targetAcc, double amount) { + targetAcc.setBalance(targetAcc.getBalance() + amount); + } + + //Change the pin of an account + @Override + public void changePin(Account acc, int pin, int newPin) { + acc.setPin(newPin); + } + + //Get the balance of an account + @Override + public double getBalance(Account acc, int pin) { + return acc.getBalance(); + } + + +} diff --git a/AccountAssignment03/src/com/demo/exception/AccountNotFoundException.java b/AccountAssignment03/src/com/demo/exception/AccountNotFoundException.java new file mode 100644 index 00000000..9c564678 --- /dev/null +++ b/AccountAssignment03/src/com/demo/exception/AccountNotFoundException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class AccountNotFoundException extends Exception{ + public AccountNotFoundException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment03/src/com/demo/exception/InsufficientBalanceException.java b/AccountAssignment03/src/com/demo/exception/InsufficientBalanceException.java new file mode 100644 index 00000000..06ba22f9 --- /dev/null +++ b/AccountAssignment03/src/com/demo/exception/InsufficientBalanceException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class InsufficientBalanceException extends Exception{ + public InsufficientBalanceException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment03/src/com/demo/exception/InvalidAmountException.java b/AccountAssignment03/src/com/demo/exception/InvalidAmountException.java new file mode 100644 index 00000000..082a7c3d --- /dev/null +++ b/AccountAssignment03/src/com/demo/exception/InvalidAmountException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class InvalidAmountException extends Exception{ + public InvalidAmountException(String msg) { + super(msg); + } +} diff --git a/AccountAssignment03/src/com/demo/service/AccountService.java b/AccountAssignment03/src/com/demo/service/AccountService.java new file mode 100644 index 00000000..89584b85 --- /dev/null +++ b/AccountAssignment03/src/com/demo/service/AccountService.java @@ -0,0 +1,17 @@ +package com.demo.service; + +import com.demo.bean.Account; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public interface AccountService { + Account acceptAccountData(int accountType); + int withdrawAmount(int id, double amount, int pin) throws AccountNotFoundException, InsufficientBalanceException; + int depositAmount(int id, double amount) throws AccountNotFoundException, InvalidAmountException; + Account searchAccountById(int id) throws AccountNotFoundException; + double getBalance(int id, int pin) throws AccountNotFoundException; + int changePin(int id, int pin, int newPin) throws AccountNotFoundException; + int transferAmount(int sourceId, int targetId, int pin, double amount) throws AccountNotFoundException, InsufficientBalanceException; + +} diff --git a/AccountAssignment03/src/com/demo/service/AccountServiceImpl.java b/AccountAssignment03/src/com/demo/service/AccountServiceImpl.java new file mode 100644 index 00000000..e3f6e405 --- /dev/null +++ b/AccountAssignment03/src/com/demo/service/AccountServiceImpl.java @@ -0,0 +1,124 @@ +package com.demo.service; +import java.text.ParseException; +import java.math.*; +import java.lang.*; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.Scanner; + +import com.demo.bean.Account; +import com.demo.bean.CurrentAccount; +import com.demo.bean.SavingAccount; +import com.demo.dao.AccountDao; +import com.demo.dao.AccountDaoImpl; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; + +public class AccountServiceImpl implements AccountService{ + public static Scanner sc = new Scanner(System.in); + public static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); + + private AccountDao accountDao; + + //Default constructor + public AccountServiceImpl(){ + this.accountDao = new AccountDaoImpl(); + } + + //Accept user data and create accounts + @Override + public Account acceptAccountData(int accountType) { + Account acc = null; + System.out.println("Enter Name :"); + String name = sc.next(); + System.out.println("Enter Balance :"); + double balance = sc.nextDouble(); + System.out.println("Enter Pin :"); + int pin = sc.nextInt(); + System.out.println("Enter Date :"); + String doj= sc.next(); + try { + Date dateOfJoining = sdf.parse(doj); + if(accountType == 1) { + acc = new SavingAccount(name, pin, balance, dateOfJoining, "Saving"); + } + else if(accountType == 2) { + acc = new CurrentAccount(name, pin, balance, dateOfJoining, "Current"); + } + accountDao.createAccount(acc); + } catch (ParseException e) { + e.printStackTrace(); + } + return acc; + } + + //Display account data to user + @Override + public Account searchAccountById(int id) throws AccountNotFoundException{ + return accountDao.searchAccountById(id); + } + + //Withdraw amount + @Override + public int withdrawAmount(int id, double amount, int pin) throws AccountNotFoundException, InsufficientBalanceException { + Account acc = accountDao.searchAccountById(id); + if(acc != null && acc.getPin() == pin) { + return accountDao.withdrawAmount(acc, amount, pin); + } + return -1; + } + + //Deposit amount + @Override + public int depositAmount(int id, double amount) throws AccountNotFoundException, InvalidAmountException { + Account acc = searchAccountById(id); + if(acc != null) { + accountDao.depositAmount(acc, amount); + } + return 1; + + } + + //Get the balance of an account + @Override + public double getBalance(int id, int pin) throws AccountNotFoundException { + Account acc = searchAccountById(id); + if(acc != null) { + return accountDao.getBalance(acc, pin); + } + return -1; + } + + //Change pin of a account + @Override + public int changePin(int id, int pin, int newPin) throws AccountNotFoundException { + Account acc = searchAccountById(id); + if(acc != null && acc.getPin() == pin) { + accountDao.changePin(acc, pin, newPin); + return 1; + } + return -1; + } + + //Transfer amount to other account + @Override + public int transferAmount(int sourceId, int targetId, int pin, double amount) throws AccountNotFoundException, InsufficientBalanceException { + Account sourceAcc =searchAccountById(sourceId); + if(sourceAcc != null) { + int result = accountDao.withdrawAmount(sourceAcc, amount, pin); + if(result != -1) { + Account targetAcc = searchAccountById(targetId); + if(targetAcc != null) { + accountDao.transferAmount(targetAcc, amount); + return 1; + } + } + } + return -1; + } + + + + +} diff --git a/AccountAssignment03/src/com/demo/test/TestAccountInheritance.java b/AccountAssignment03/src/com/demo/test/TestAccountInheritance.java new file mode 100644 index 00000000..ff6c6cd9 --- /dev/null +++ b/AccountAssignment03/src/com/demo/test/TestAccountInheritance.java @@ -0,0 +1,153 @@ +package com.demo.test; + +import java.util.Date; +import java.util.Scanner; + +import com.demo.bean.Account; +import com.demo.bean.SavingAccount; +import com.demo.exception.AccountNotFoundException; +import com.demo.exception.InsufficientBalanceException; +import com.demo.exception.InvalidAmountException; +import com.demo.service.AccountService; +import com.demo.service.AccountServiceImpl; + +public class TestAccountInheritance { + + public static void main(String[] args) { + AccountService accountService = new AccountServiceImpl(); + + Scanner sc = new Scanner(System.in); + int choice = 0; + + //Menu to be displayed + do { + System.out.println("1. Create new account"); + System.out.println("2. Withdraw amount"); + System.out.println("3. Make a deposit"); + System.out.println("4. Transfer fund"); + System.out.println("5. Change pin"); + System.out.println("6. Check balance"); + System.out.println("7. Display account by Id"); + System.out.println("8. Exit"); + + choice = sc.nextInt(); + int id = 0; + double amount = 0; + int accountType = 0; + + switch(choice) { + case 1: + System.out.println("1. Saving Account"); + System.out.println("2. Current Account"); + System.out.println("Enter type of account"); + accountType = sc.nextInt(); + Account acc = accountService.acceptAccountData(accountType); + System.out.println("Account created"); + System.out.println(acc); + break; + case 2: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + System.out.println("Enter the pin"); + int pin = sc.nextInt(); + int result; + try { + result = accountService.withdrawAmount(id, amount, pin); + if(result != -1) { + System.out.println("Successful withdrawal"); + } + } catch (AccountNotFoundException e5) { + System.out.println(e5.getMessage()); + } catch (InsufficientBalanceException e) { + System.out.println(e.getMessage()); + } + break; + case 3: + System.out.println("Enter Id"); + id = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + try { + result = accountService.depositAmount(id, amount); + System.out.println("Deposit Successful"); + } catch (AccountNotFoundException e4) { + System.out.println(e4.getMessage()); + } catch (InvalidAmountException e) { + System.out.println(e.getMessage()); + } + + break; + case 4: + System.out.println("Enter Id of source account:"); + int sourceId = sc.nextInt(); + System.out.println("Enter Id of target account"); + int targetId = sc.nextInt(); + System.out.println("Enter the pin of source account"); + pin = sc.nextInt(); + System.out.println("Enter the amount"); + amount = sc.nextDouble(); + try { + result = accountService.transferAmount(sourceId, targetId, pin, amount); + if(result != -1) { + System.out.println("Transfer Successful"); + } + else { + System.out.println("Transfer failed"); + } + } catch (AccountNotFoundException e3) { + System.out.println(e3.getMessage()); + } catch (InsufficientBalanceException e) { + System.out.println(e.getMessage()); + } + + break; + case 5: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the current pin"); + pin = sc.nextInt(); + System.out.println("Enter the new pin"); + int newPin = sc.nextInt(); + try { + result = accountService.changePin(id, pin, newPin); + if(result != -1) { + System.out.println("Pin changed"); + } + else { + System.out.println("Cannot change pin"); + } + } catch (AccountNotFoundException e2) { + System.out.println(e2.getMessage()); + } + + + break; + case 6: + System.out.println("Enter Id:"); + id = sc.nextInt(); + System.out.println("Enter the pin"); + pin = sc.nextInt(); + try { + System.out.println("Account balance is :" + accountService.getBalance(id, pin)); + } catch (AccountNotFoundException e1) { + System.out.println(e1.getMessage()); + } + break; + case 7: + System.out.println("Enter Id :"); + id = sc.nextInt(); + try { + System.out.println(accountService.searchAccountById(id)); + } catch (AccountNotFoundException e) { + System.out.println(e.getMessage()); + } + break; + case 8: + System.exit(0); + } + }while(choice != 8); + + } +} From 97208c1c39009bd1e0b04dfd53c1309f4e9e8e48 Mon Sep 17 00:00:00 2001 From: abhijeet Date: Wed, 23 Sep 2020 17:43:01 +0530 Subject: [PATCH 4/6] Testing README file --- README.docx | Bin 0 -> 12181 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 README.docx diff --git a/README.docx b/README.docx new file mode 100644 index 0000000000000000000000000000000000000000..b566906c13f57c02e0685b6c542527b67cc1babd GIT binary patch literal 12181 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 Date: Wed, 23 Sep 2020 17:45:04 +0530 Subject: [PATCH 5/6] Delete README.docx --- README.docx | Bin 12181 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 README.docx diff --git a/README.docx b/README.docx deleted file mode 100644 index b566906c13f57c02e0685b6c542527b67cc1babd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12181 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 Date: Thu, 24 Sep 2020 17:54:47 +0530 Subject: [PATCH 6/6] Practical exam --- Practical_exam_Abhijeet_Raut_WFS4/.classpath | 6 ++ Practical_exam_Abhijeet_Raut_WFS4/.project | 17 ++++ .../.settings/org.eclipse.jdt.core.prefs | 12 +++ .../bin/com/demo/bean/Apparel.class | Bin 0 -> 1447 bytes .../bin/com/demo/bean/Electronics.class | Bin 0 -> 1201 bytes .../bin/com/demo/bean/FoodItems.class | Bin 0 -> 1820 bytes .../bin/com/demo/bean/Product.class | Bin 0 -> 2531 bytes .../bin/com/demo/dao/ProductDao.class | Bin 0 -> 276 bytes .../bin/com/demo/dao/ProductDaoImpl.class | Bin 0 -> 1754 bytes .../exception/InvalidNumberException.class | Bin 0 -> 392 bytes .../demo/exception/NoProductsException.class | Bin 0 -> 383 bytes .../exception/ProductExistException.class | Bin 0 -> 389 bytes .../bin/com/demo/service/ProductService.class | Bin 0 -> 265 bytes .../com/demo/service/ProductServiceImpl.class | Bin 0 -> 3109 bytes .../bin/com/demo/test/TestProduct.class | Bin 0 -> 1790 bytes .../src/com/demo/bean/Apparel.java | 47 +++++++++ .../src/com/demo/bean/Electronics.java | 33 ++++++ .../src/com/demo/bean/FoodItems.java | 46 +++++++++ .../src/com/demo/bean/Product.java | 95 ++++++++++++++++++ .../src/com/demo/dao/ProductDao.java | 20 ++++ .../src/com/demo/dao/ProductDaoImpl.java | 86 ++++++++++++++++ .../exception/InvalidNumberException.java | 8 ++ .../demo/exception/NoProductsException.java | 7 ++ .../demo/exception/ProductExistException.java | 9 ++ .../src/com/demo/service/ProductService.java | 15 +++ .../com/demo/service/ProductServiceImpl.java | 89 ++++++++++++++++ .../src/com/demo/test/TestProduct.java | 36 +++++++ 27 files changed, 526 insertions(+) create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/.classpath create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/.project create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/.settings/org.eclipse.jdt.core.prefs create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Apparel.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Electronics.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/FoodItems.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Product.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/dao/ProductDao.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/dao/ProductDaoImpl.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/InvalidNumberException.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/NoProductsException.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/ProductExistException.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/service/ProductService.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/service/ProductServiceImpl.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/test/TestProduct.class create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Apparel.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Electronics.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/FoodItems.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Product.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDao.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDaoImpl.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/InvalidNumberException.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/NoProductsException.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/ProductExistException.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductService.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductServiceImpl.java create mode 100644 Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/test/TestProduct.java diff --git a/Practical_exam_Abhijeet_Raut_WFS4/.classpath b/Practical_exam_Abhijeet_Raut_WFS4/.classpath new file mode 100644 index 00000000..51a8bbad --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/.classpath @@ -0,0 +1,6 @@ + + + + + + diff --git a/Practical_exam_Abhijeet_Raut_WFS4/.project b/Practical_exam_Abhijeet_Raut_WFS4/.project new file mode 100644 index 00000000..e0e2141c --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/.project @@ -0,0 +1,17 @@ + + + Practical_exam_Abhijeet_Raut_WFS4 + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/Practical_exam_Abhijeet_Raut_WFS4/.settings/org.eclipse.jdt.core.prefs b/Practical_exam_Abhijeet_Raut_WFS4/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 00000000..ec1937b3 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,12 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.release=disabled +org.eclipse.jdt.core.compiler.source=1.8 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Apparel.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Apparel.class new file mode 100644 index 0000000000000000000000000000000000000000..41964524c273c60f250885b827d2db4330aa9e75 GIT binary patch literal 1447 zcmZ`&>rN9<5dKbY+sj(YN()#N5X5#1tQWi%P%avqR3O2S5aW++d&DKZxok=F349oT zXd+-V@d11&_yu4In+kja$#SD+RAjATl%!cV)|ySz zmQ@9TzN;O(QE8POfxwaVQ3{BHK)7Z)(zeX1fL1&-k4>X$)(?zb$F}MRd4bTfRkxf~ z0e>dDN0}Rqij2aKODZCWMj$YxB8U)s!zvVn>7;1Y}RJ-dRTiqs4&@Q0-i%&`)WzFyJt|$DGEP)40Ic;5_CZwj5dG9z1u;tdSdOQI9*e zRc28(>FRyUtUH$TK|nc>&aSH#2|#)&N9X%Mrof0X3V7Mka3quMr%XYVbrF=z^vAg5 zoJL!B1zFOi_iwDXtZGHt+-Xk5P0U8I07Jo|K%zHR#Vy<>w#R0*CAZ%S%yrk?E*;9U zlOI4eiVW_ujB{b!6Nr1$H1(P%W`%DbsCbA+G#F;HDeD!1g>GbTZu*fu@_B~HGsLpM z1S#03#Cc#CG<31~sq^_<3F9gKoi_}S6Nv6MT6S4Jw|Kl%kLDuFfN2^1Bs}2Ju9kwGmZovtOJ1dD zE*sL*)X0T6QTH@WwtSlvVtUwVj44kU5|bA3c||7h7JGDGEN z|3icoVIuToJgj}vj}lpcrR^tZ(Vmbw#ab`rY!_vt KqusjO*v4PTzW=HK literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Electronics.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Electronics.class new file mode 100644 index 0000000000000000000000000000000000000000..3beaecd963cc0a2fddfcfc690ac7b24b1b906640 GIT binary patch literal 1201 zcmZ{iZEw<06vzK}JQQjj6=4IJa~o~~ZmSRT5w;gPO-R^7GDBjFFG{(xF3`@>F7Z40 zLK9_16F-0-%6M+uXki#ad++K0{Lk;6dw%`?{u96!wk6Ck6b*Zzb@{;7I$XE37kzHH zj%}I7P(qv`KmPg9vAdq(G9(AK|sJOv|+RzBlM_=at^+bB1ioHuQd5cTBMlgK_uRB=1sdym|z#PUMwl>qI}(wZ3lk zv?JFstzLb%*{rrj?VPBcXDCcp3C@)1@_}Ftm;3s_2fAR&koM?+hmL8GfbEk0y{B8Q z>3*P3J?`#>&7kvBJJQ2{k$8o8NblMKAVaQFy@)NL%rHM$_?c(+yWA1SSyixvWf`|n zl~7?&C$$P{xXmD)>3xqMykl6aM9Lg=PUv3iQ!2|?!G`G7CS7(kC2VN5ox&ZWj`V)% zO>p_!BKMwx``Drx&`(df)n(Y2W)eXOe8Z#Fg~dZ*@rYr8di7sn3Qwr@Z-su9K|ZoQ z$KWqbF+ysDZBz6G%QSK^8ghmiF?X~|(3)nEo@v@OD9-3D*Usr5`wHbV?Pf4b&sje+ zg*YkGkddL75~!i#3hjhbHgs~yU80y;E3H@aiE~`7<&#tVX2~lbAc*!AidvKQJAJO^x7j>0aE^fmDkkRo8Pc@j`gfI!d<~O Z!h`H%T95Gb(*)*X1hf1Xv+k=Je*mGCr&HD5Xb+AOB-sS7+Wqi8kF5#zK8hJ?{~@e%x> zGXjpz_y9hXr-pX59}wOJKPA-rO?Ffp0g<3$$DjP{XhX zA2)38lR#$6TDN@DvrR`pyb?&=wjJA_6S!Gg3U@b6XTAK~_iSgqvJm+?8Ivcx(rW^J z_uYn-K`(|>WRMjY>z+)n4S>j1^drUA5f$ms%BxT?Ads!vj9wJ@5tHbzq2<5#;g0qX)8yCD>g~UTvX>$^tocTWJak{yiS3EfMj^;*>#Rzp!g4g z>G-x!n&n6_Rx=^CR??GVQ0!*c*dwK6D9e^@C*EsMw!MANquQIbSj&1#IyG&O!s6b( zl5B(GyJ6pmV-GG~Wg6#c*pkK12X?bzdECAWD$Zd#gG;!Q#$}qPWUPv-xF(R^GMfSE zAutscCXZQNdvDeKN+e7CQ&agS5XCw3l)zPD2W4Mldk7{5-l3Kppu)5XrEl8}%11e&=5 zwdFt*1y5+w-Z0Sxx|h%0z^hw}Hjn&JTZZ%80Gyz!(o6q~Ui9$IA*+Y)jeOIsp|?U2 z862XgN?)I8jlBh9Vp`Al?_$sxPiupmj((qdL7J%N)EX_?-f zt>5^L;jd)$5Do~RojHl1h5-?Rz$u(250^Pd(F~9>&QWolf-=%ON(f^z!$=s_E+Qr2 z_~0{LL9`^u(XJp<-9fY@$Rr(i>;Mq%B7>YoDJm+iNbU<&7gwa%6-0*-ZSE*Cv9HCU zBBu!C^Z_8;8U~^3ALVLMOSub`UzmAm?4tYw7k6=8yS0Pc+^rql)$WJ3#`c5I&h6l# e_L%G)R69Bj$@$PJy@Bh{V`Ws@ja`<-uKWX^xnk!4 literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Product.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/bean/Product.class new file mode 100644 index 0000000000000000000000000000000000000000..b5e048dfd63e0a3c0cd279ff2c3d025b824b2a59 GIT binary patch literal 2531 zcmaJ?Yfl?j5IyTRW_iS541^@6X@b2rxJ~FI0h|C1saqhV5b|nTEoKEvZ7(%;rGD!_ z=|gHiMQSP)M{1?2-zxPtRaMXIF1GO_AG|yF?%X+N&dgl@^WX1(0+`1aL3k8I3sxz! zZu z)!L`2^K}F>sCQ8 z?&=j&*6yaSdT5>~h^==Of>g&7`OXY-dEwT7U{v#syvdiD_n)-x`4Z5 zgm90lr{fY#M7M+8mk=K*nC+(j8$x}|Dx~9$wzgxfORNoHk$V%12R4hd30Ml@A&26H zE)oj^mUIL3fcx4wbO=4dD{P4je!^<1UBcp4-Ik@(lW6Spt z{W$1+4s-R`J_k%_uW>>1o?=8(P7&1xPZ5*l#IN?zi+oNZz-K=p zmfivp&?JqfIAMD?PN-=+!kFXLpc!y!DtH^$+*qwdqOaPBTkzoj$?HX z8rG=WeVa+#L2LBd9NxqG`2mN~gAW;-gB$d#|KdW>&XxC`OV{FYss7R*xcxM; z_!?OuR>$2)u8uX@QNAL1$BxzUNo3QpC&Xuqb{(HK+jr1rv%#uw@^am1(Q2tNPrM&p z@FTL5d77d;yOd}5M^Wr-@x3VHX(}^DO~Bi=pXUd7ca7r-6?xuL)~SXHQ&izHQ6zWX oiUaEKGEY8nag#1?pC+ZK<7s=h@n3}pg_?%|^85@h?DyyY188TW3;+NC literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/dao/ProductDao.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/dao/ProductDao.class new file mode 100644 index 0000000000000000000000000000000000000000..6db5d600f9503fddc2bf38ce51c995741d1ed87e GIT binary patch literal 276 zcmZ{fJqp4=6olvblbEO|SXg)g1L8Jzij@d~fI`52%`PD!$wJ(CI13Npp~Q{&Q;6L# z%s21N?S8oeSfFpCK^R9WXF}$R39i__RHBOXhASH_!Z77$&N5!aYF#Aoc{`9X6>V~Q+ nBe_j7!w$Zm&+8)=fzUKNfrc5Y}j6g|%#XB=np(KyC+laMrNQ@cq!K-;9nsY{!-!r(xqpde5rG#(Ghl(EMe zkC6&2L1M)UsS*+rAB${hS%ee`Ravs_AK-7Wpm5&Ibeyyawmg3C&OP_tbMAS6K7I5D zfQz`LA|Wttx=p=dHC?@7xcVK>ZFEilrr}nbZAXP7Fml)U)X*KHwW+^bziXMkiavq- z5io(lk6pJ>^{r;7W_NtzYe9joZ#%k-lm+_N?9G^xW&^T3oqq8Lej>l`F() zM!RizmJ?MTwj8$Oxh>m_BI#w*v0JuZ5l9wG>jKJ(+pts|6Ug?uxbAtzJ=sbIBgkqP z!;nDVascdyz)Kobq~+?khJkQ(LW731z;MlOS?_e4b<2Cts5>MuT60aqSvNde?t@?k zNo0Arzh!p>CVPxtl$fkCMxznw&T$lb*$4PnOX~xe#c36%1crKKBo7U9I77-TB#hq%`mxULj zM-McES8+kbYwWqlXT^2oRBgA_(P+|3l(FM_^iekA)iYA4$dZQ3xFXZ+&)7NVUX?Z1GC*&6x%_+NhJ%PulgtWd?L{91Z@!!9;@%eZv zz~=*e{!o1WfAD3h5kL!vLJLPi7k(iNB@nO9@d6hp;YB*-60%sNSWB4UwJ72WZ^067 z@%bjMVigsv;TksZ2I{zuE!@BtTz`ez_?j8tpo;r=3*XaeKcj{nt{>x0ApS<6htVyBaVF($L`0m@8Z}Ea*z%St7W25&O&>N85Ofa X6cT?U{SON9YAjr(2wEXHft&vU*j;D& literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/InvalidNumberException.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/InvalidNumberException.class new file mode 100644 index 0000000000000000000000000000000000000000..fbcf13e4845983dd86ed7c15fb5b408928f54d2d GIT binary patch literal 392 zcma)2u};G<6ug&)1VW*u2o@$bN+rCo6?H)%Aw?`j-QC0r4<$BA(~95fgv7uH@KK0o zT3~8@tdY=eP4}YU-;mIz~v? zf6xo9N^J}EeL;vW*m5%>9Gs*-f^k!`Er$IGA-r_CNzlSp8ykoSos_Lv4YHG8}!!{(l6ghBf6ltV(RnibyfR}w-pcJn$j*X$=A{r%1}--ly}k^B>6C!bkr rENFy477(2dp0T-|{Nc7l6=hLezD8SwaT@GK& literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/NoProductsException.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/NoProductsException.class new file mode 100644 index 0000000000000000000000000000000000000000..0e455fdb729038e5c3acc8056e6b61f74e0be42a GIT binary patch literal 383 zcma)2Jx{|h6ug(F34}tS2*k>Q3P@yOE9!z^iYla{?yh46qr^sugZNuaNDTY{eiY(4 zd<`%lOV7UZ`QAOhzCFJHIK?PNKsb=LN^@1&R6R&_=d?BH%wE+tZ>4K4zPK16Vf$9x zi?kG`NWU)#(U~^dO$j^W>_;$nwKm1%a6t&qZLSjZusT2=5n-5Vqh@WjRQ0u3mWnXS ztQ6%!)Y{`uGITe(A&j&CMVt_NRa1DgUoi;D+_tq;m)f`6`(wfr{|NhF7ycgbPChNy sn9&pgFCaQPe!|Klp8_OYlaB3o$~DHjA1Vy6&WQEcz_9b$WE5cQ9iEpF literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/ProductExistException.class b/Practical_exam_Abhijeet_Raut_WFS4/bin/com/demo/exception/ProductExistException.class new file mode 100644 index 0000000000000000000000000000000000000000..70408c45f90bce9003161b11692af7ac9942ad2e GIT binary patch literal 389 zcma)2u};G<6ug&)1VW*u2nIH`QY5ml6?H*niV#v!cQ>(uQDP&Rl1y>ED7PIDP)2kw))sWL>OdB%j>pYNqZ|+l_ZQZ zlZ$F8tn$1QLwBbd!X*1|$tj^%H>HpJRfLc%Olxy_rTm3Qf4=g}AHy*?hd&8ClW)uz rGn*mc0YsD2XKX(4DnP=Re5ve=vCaIj<9+NfV?TB=_{0eYxtEDNIDy&var zzk7dNZvZx!IIswFQDiKVS-~n?SNoL0VFfrnYE8TcXvX4Ybr2u&F?6)1uVtvf0vYliiqXTJV0q z*1OibR$uz6tp$}Co$zQvRlNcRM%?JJa1q8`R3bj#oq8tS33p6)TLD9}~K zU}efk;PgzU%q8l^QZm{WY}3$-8win8au?V405hu8SH*UwGi1AFA!-qks6imZ=)(>L z{UnoDL1MBV{jAFh?_Nhn{Gx%8R&)+XUA8vgUN&T2X95pmW@u zGF{05dmtLSHW{5Ti&5RqM7JiRV@_Oh><$fg;x2)@yk01hHyfAZnqLjCgJpmADY!>q z%>sWWP2ElmJ5DA=z=~nq4PDY~Qeb;5b!jCB%V$-4|FwT4J|0E}M-?!lwrbNHkTDKT z8)n|M99zQ_8VRU}d)n2F6Nd`AK};+{=ohGH-ET%MJ8FBaq2dH`m3F8gBt(b0uop?1@MStOwOVneb`W~fQ2wZ4=$ zgO}2YV=Ex}!tiL9N3l^o?+sH0XO`X{-dI-f_9g6Dn1l7~#qx%uw1rb~ zQN$xwQQml=v^8bxY<`BZ`BI7g6>7M%Pcq;`4e#Jx*4&42D+`x)N(I9lw&aztrtEyt z?cO87#Ci_;TK?DZJ0veF{zeGNi-pe`Isf?#@U#Jql)8+&os^WHwex72IFIHzv|T{Q zJUSdch6(f#2mIclHA-TW3vLEOTw}z<|3iQ^W zL$J2D{ye%O>MV{VHMt7ORl_{)p6J-p7HADdv`9m1{T%L1D(7G&wTLzg;~eg3uRDwF z((QBL6{&$?#5npiV)_S0Q=zU*7&^uZ3bu4_8tM%x@mDqv}*oKYR!QBw$_7ad$#BmtixQjm= zOl(GuQYG}@Ap-OSA$pnsJ;xuOr*Q+$;6^Yn`b**~^y3>0;9Km%cf7NIz;67AJ@^TO z_zlDOgBSB(NQpY^6AidUbYe_&^JbMqnkAtKbD08i^$;GGBoG~VgsU2Ki69=uW6WtA ze#hgCB*2J&#glv+WZb{tDMqF+>Pb99IhAoA#Isz5Xlpkkewbu>n)=V<1vbKIlFVP7 zVNFisMYhISwBjYM8kkERUdAgt`;irTmAWc(Xu)gJ9;07{*S)hh7<(Ur|ImC`fe=E$ zo3;FUi%rpPvDdhgLt4c_-Ua)2w@XY~?SqWVD%KJ{M9 d77S7a#79F!yEnGX0D8rxi@T8^R*T@nKV7k!wzXO+_hL$__y z?ZP02C5F!UTG+37W+jFZToMQ=3W){*%Sq?#YTY9TQ?F#Bh~tX#dsJX};@m5fMfJng z7?K!g%$zzy*aF+2D@`yB*9FFIr;>}MQnK0*Av&E(-Z#CZw`(RX`>_+nn|NE|ErGc2 z3Hh`^#4v$L0a;b3WyLz+?nXdn(p?l_z z?70=~R?tLA09 z@jezMJ`m__39l?Me266h&7!Be=eR1z+F#Q}|C|WRxG%B7u(S}G))-ciBQX_2fq^DM zTe)NnL2{@n{SSCRAwNGZjQ0W1K;YTQ--)n%esZ9^ z2$MUo&e8{2Yvdd!>jXRFF#6e?;>^YY+~UbB`_(-RVTqPiw!jTsLIGFsHAYd#7=GmZ zGsE`_uKCee^}}|+JDbGT@Dn~qk@1M*2Yi7q8Qui;v4w|>%`o=xh^sKsrtlTV2r)H$ zgKrt(@AzKDwqet0+vdq4A}4$pkuW4?CE|igWKM{xwH-;8x@5f|enLggUM6ITKp~j_ E0!H?#3jhEB literal 0 HcmV?d00001 diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Apparel.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Apparel.java new file mode 100644 index 00000000..47b3609f --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Apparel.java @@ -0,0 +1,47 @@ +package com.demo.bean; + +public class Apparel extends Product{ + private int size; + private String material; + + //default constructor + public Apparel() { + super(); + this.size = 0; + this.material = null; + } + + //parameterized constructor + public Apparel(int itemCode, String itemName, double unitPrice, int quantity, int size, String material) { + super(itemCode, itemName, unitPrice, quantity); + this.size = size; + this.material = material; + } + + //setters and getters + public int getSize() { + return size; + } + + public void setSize(int size) { + this.size = size; + } + + public String getMaterial() { + return material; + } + + public void setMaterial(String material) { + this.material = material; + } + + //to display product + @Override + public String toString() { + return super.toString() + "Apparel [size=" + size + ", material=" + material + "]"; + } + + + + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Electronics.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Electronics.java new file mode 100644 index 00000000..221240fc --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Electronics.java @@ -0,0 +1,33 @@ +package com.demo.bean; + +public class Electronics extends Product{ + private int months; + + //Default constructor + public Electronics() { + super(); + this.months = 0; + } + + //Parameterized constructor + public Electronics(int itemCode, String itemName, double unitPrice, int quantity,int months) { + super(itemCode, itemName, unitPrice, quantity); + this.months = months; + } + + //setters and getters + public int getMonths() { + return months; + } + + public void setMonths(int months) { + this.months = months; + } + + //to display the product + @Override + public String toString() { + return super.toString() + "Electronics [months=" + months + "]"; + } + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/FoodItems.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/FoodItems.java new file mode 100644 index 00000000..8d3c028b --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/FoodItems.java @@ -0,0 +1,46 @@ +package com.demo.bean; + +import java.util.Date; + +public class FoodItems extends Product{ + private Date dateOfManufacture; + private Date dateOfExpiry; + private boolean vegetarian; + + //parameterized constructor + public FoodItems(int itemCode, String itemName, double unitPrice, int quantity, Date dateOfManufacture, Date dateOfExpiry, boolean vegetarian) { + super(itemCode, itemName, unitPrice, quantity); + this.dateOfManufacture = dateOfManufacture; + this.dateOfExpiry = dateOfExpiry; + this.vegetarian = vegetarian; + } + + //setters and getters + public Date getDateOfManufacture() { + return dateOfManufacture; + } + public void setDateOfManufacture(Date dateOfManufacture) { + this.dateOfManufacture = dateOfManufacture; + } + public Date getDateOfExpiry() { + return dateOfExpiry; + } + public void setDateOfExpiry(Date dateOfExpiry) { + this.dateOfExpiry = dateOfExpiry; + } + public boolean isVegetarian() { + return vegetarian; + } + public void setVegetarian(boolean vegetarian) { + this.vegetarian = vegetarian; + } + + //to display product + @Override + public String toString() { + return super.toString() + "FoodItems [dateOfManufacture=" + dateOfManufacture + ", dateOfExpiry=" + dateOfExpiry + ", vegetarian=" + + vegetarian + "]"; + } + + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Product.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Product.java new file mode 100644 index 00000000..f4a3fe26 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/bean/Product.java @@ -0,0 +1,95 @@ +package com.demo.bean; + +public class Product implements Comparable{ + private int itemCode; + private String itemName; + private double unitPrice; + private int quantity; + + // default constructor + public Product() { + super(); + this.itemCode = 0; + this.itemName = null; + this.unitPrice = 0.0; + this.quantity = 0; + } + + //Parametrized constructor + public Product(int itemCode, String itemName, double unitPrice, int quantity) { + super(); + this.itemCode = itemCode; + this.itemName = itemName; + this.unitPrice = unitPrice; + this.quantity = quantity; + } + + //Setter and getter methods + public int getItemCode() { + return itemCode; + } + public void setItemCode(int itemCode) { + this.itemCode = itemCode; + } + public String getItemName() { + return itemName; + } + public void setItemName(String itemName) { + this.itemName = itemName; + } + public double getUnitPrice() { + return unitPrice; + } + public void setUnitPrice(double unitPrice) { + this.unitPrice = unitPrice; + } + public int getQuantity() { + return quantity; + } + public void setQuantity(int quantity) { + this.quantity = quantity; + } + + + + @Override + public int hashCode() { + return itemCode; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Product other = (Product) obj; + if (itemCode != other.itemCode) + return false; + return true; + } + + //To print the object + @Override + public String toString() { + return "Product [itemCode=" + itemCode + ", itemName=" + itemName + ", unitPrice=" + unitPrice + ", quantity=" + + quantity + "]"; + } + + //Method to sort the products based on quantity + @Override + public int compareTo(Product obj) { + if(this.getQuantity() < obj.getQuantity()) { + return 1; + } + else if(this.getQuantity() == obj.getQuantity()) { + return 0; + } + else { + return -1; + } + } + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDao.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDao.java new file mode 100644 index 00000000..e1667c07 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDao.java @@ -0,0 +1,20 @@ +package com.demo.dao; + +import java.util.List; +import java.util.Set; + +import com.demo.bean.Product; + +//Interface for dao layer +public interface ProductDao { + + //Dao layer methods + void addProduct(Product product, int choice); + + List getProducts(int choice2); + + + + + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDaoImpl.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDaoImpl.java new file mode 100644 index 00000000..b3954e82 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/dao/ProductDaoImpl.java @@ -0,0 +1,86 @@ +package com.demo.dao; + +import java.io.EOFException; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import com.demo.bean.Product; + +//Class to handle storage related operations +public class ProductDaoImpl implements ProductDao{ + + //static block to initialize same storage for all products + static { + foodItemsList = new ArrayList<>(); + apparelsList = new ArrayList<>(); + electronicsList = new ArrayList<>(); + } + private static List foodItemsList; + private static List apparelsList; + private static List electronicsList; + + + //Method to add new product to storage + @Override + public void addProduct(Product product, int choice) { //choice for checking the category of product + if(choice == 1) { + foodItemsList.add(product); + } + else if(choice ==2) { + apparelsList.add(product); + } + else { + electronicsList.add(product); + } + } + + + //To get top 3 the products based on quantity + @Override + public List getProducts(int choice) { + List tempList = new ArrayList<>(); + if(choice == 1) { + Collections.sort(foodItemsList); + int size = foodItemsList.size(); + for(int i = 0;i<3;i++) { + if(i < size) { + tempList.add(foodItemsList.get(i)); + } + } + } + else if(choice ==2) { + Collections.sort(apparelsList); + int size = apparelsList.size(); + for(int i = 0;i<3;i++) { + if(i < size) { + tempList.add(apparelsList.get(i)); + } + + } + } + else { + Collections.sort(electronicsList); + int size = electronicsList.size(); + for(int i = 0;i<3;i++) { + if(i < size) { + tempList.add(electronicsList.get(i)); + } + } + } + return tempList; + + } + + + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/InvalidNumberException.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/InvalidNumberException.java new file mode 100644 index 00000000..24c6a4b3 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/InvalidNumberException.java @@ -0,0 +1,8 @@ +package com.demo.exception; + +//Exception if number is not valid +public class InvalidNumberException extends Exception{ + public InvalidNumberException(String msg) { + super(msg); + } +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/NoProductsException.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/NoProductsException.java new file mode 100644 index 00000000..fb68ad66 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/NoProductsException.java @@ -0,0 +1,7 @@ +package com.demo.exception; + +public class NoProductsException extends Exception{ + public NoProductsException(String msg) { + super(msg); + } +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/ProductExistException.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/ProductExistException.java new file mode 100644 index 00000000..b96e4293 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/exception/ProductExistException.java @@ -0,0 +1,9 @@ +package com.demo.exception; + +//Exception when product exists already +public class ProductExistException extends Exception{ + public ProductExistException(String msg) { + super(msg); + } + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductService.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductService.java new file mode 100644 index 00000000..1b7d8d92 --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductService.java @@ -0,0 +1,15 @@ +package com.demo.service; + +import java.util.List; + +import com.demo.bean.Product; + +//Interface for service layer +public interface ProductService { + + //Methods for service layer + void addProduct(int i); + + List getProducts(int choice2); + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductServiceImpl.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductServiceImpl.java new file mode 100644 index 00000000..2f25b0eb --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/service/ProductServiceImpl.java @@ -0,0 +1,89 @@ +package com.demo.service; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.List; +import java.util.Scanner; + +import com.demo.bean.Apparel; +import com.demo.bean.Electronics; +import com.demo.bean.FoodItems; +import com.demo.bean.Product; +import com.demo.dao.ProductDao; +import com.demo.dao.ProductDaoImpl; + +public class ProductServiceImpl implements ProductService { + public static Scanner sc = new Scanner(System.in); + public static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy"); + + private ProductDao productDao; + + public ProductServiceImpl() { + this.productDao = new ProductDaoImpl(); + } + + //To add product to database/storage + @Override + public void addProduct(int choice) { + System.out.println("Enter item code"); + int itemCode = sc.nextInt(); + System.out.println("Enter item name"); + sc.next(); + String itemName = sc.nextLine(); + System.out.println("Enter unit price"); + double unitPrice = sc.nextDouble(); + System.out.println("Enter quantity"); + int quantity = sc.nextInt(); + + Product product = null; + if(choice == 1) { + System.out.println("Enter manufacturing date. (dd/MM/yyyy)"); + String mDate = sc.next(); + System.out.println("Enter expiring date. (dd/MM/yyyy)"); + String eDate = sc.next(); + System.out.println("Vegetarian? (1: Yes and 2: No)"); + int vegetarianFlag = sc.nextInt(); + boolean vegetarian; + if(vegetarianFlag == 1) { + vegetarian = true; + } + else { + vegetarian = false; + } + try { + Date dateOfManufacture = sdf.parse(mDate); + Date dateOfExpiry = sdf.parse(eDate); + product = new FoodItems(itemCode, itemName, unitPrice, quantity, dateOfManufacture, dateOfExpiry, vegetarian); + } catch (ParseException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + else if(choice == 2) { + System.out.println("Enter size in number"); + int size = sc.nextInt(); + System.out.println("Enter material (cotton/woolen)"); + String material = sc.next(); + + product = new Apparel(itemCode, itemName, unitPrice, quantity, size, material); + } + else { + System.out.println("Enter warranty in months"); + int warranty = sc.nextInt(); + product = new Electronics(itemCode, itemName, unitPrice, quantity, warranty); + } + + productDao.addProduct(product, choice); + + } + + //To get the products from database/storage + @Override + public List getProducts(int choice2) { + return productDao.getProducts(choice2); + + } + +} diff --git a/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/test/TestProduct.java b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/test/TestProduct.java new file mode 100644 index 00000000..5474b05c --- /dev/null +++ b/Practical_exam_Abhijeet_Raut_WFS4/src/com/demo/test/TestProduct.java @@ -0,0 +1,36 @@ +package com.demo.test; + +import java.util.List; +import java.util.Scanner; + +import com.demo.bean.Product; +import com.demo.service.ProductService; +import com.demo.service.ProductServiceImpl; + +public class TestProduct { + + public static void main(String[] args) { + ProductService productService = new ProductServiceImpl(); + Scanner sc=new Scanner(System.in); + int choice1 = 0; //to decide to add or fetch products + int choice2 = 0; // to decide the category of products + do { + System.out.println("1. Add product\n2. Get the info"); + choice1 = sc.nextInt(); + System.out.println("Enter the category"); + System.out.println("1. Food Item\n2. Apparel\n3. Electronics\n4. Exit"); + System.out.println("Enter Choice:"); + choice2 = sc.nextInt(); + if(choice1 == 1) { + productService.addProduct(choice2); + } + else { + List productList = productService.getProducts(choice2); + for(Product product : productList) { + System.out.println(product); + } + } + }while(choice2 != 4); + } + +}