KbREcV8g

1/*
2 * Program Development Start Date : 10/23/2018
3 * Partnered Application Project
4 * Problem :
5 */
6package partneredapplication;
7// Main Utility
8import java.util.*;
9import java.util.ArrayList;
10
11// XML Parsing Packages
12import javax.xml.parsers.DocumentBuilderFactory;
13import javax.xml.parsers.DocumentBuilder;
14import javax.xml.parsers.ParserConfigurationException;
15import javax.xml.transform.TransformerFactory;
16import javax.xml.transform.Transformer;
17
18// File Handling Packages
19import java.io.IOException;
20import java.io.File;
21import java.io.FileReader;
22import javax.xml.transform.OutputKeys;
23import javax.xml.transform.TransformerConfigurationException;
24import javax.xml.transform.TransformerException;
25import javax.xml.transform.dom.DOMSource;
26import javax.xml.transform.stream.StreamResult;
27
28// XML Handlers
29import org.w3c.dom.Document;
30import org.w3c.dom.Element;
31import org.w3c.dom.Text;
32import org.w3c.dom.Node;
33import org.w3c.dom.NodeList;
34import org.xml.sax.SAXException;
35
36// Encryption Packages
37import java.io.IOException;
38import javax.crypto.KeyGenerator;
39import java.io.UnsupportedEncodingException;
40import java.security.InvalidKeyException;
41import java.security.NoSuchAlgorithmException;
42import java.security.spec.InvalidKeySpecException;
43import java.sql.Connection;
44import java.sql.DriverManager;
45import java.sql.PreparedStatement;
46import java.sql.ResultSet;
47import java.sql.SQLException;
48import java.sql.Statement;
49import javax.crypto.BadPaddingException;
50import javax.crypto.Cipher;
51import javax.crypto.IllegalBlockSizeException;
52import javax.crypto.NoSuchPaddingException;
53import javax.crypto.SecretKey;
54import javax.crypto.SecretKeyFactory;
55import javax.crypto.spec.DESKeySpec;
56
57/**
58 * Group Members
59 * @author cs.evsnyder
60 * @author cs.cwberg
61 */
62
63public class PartneredApplication {
64 
65    public static String computerusername = System.getProperty("user.name");
66    // Account Information Database
67    public static ArrayList<String> StoredUsernames = new ArrayList<String>();
68    public static ArrayList<String> StoredPins = new ArrayList<String>();
69    public static ArrayList<String> StoredIds = new ArrayList<String>();
70    public static ArrayList<SecretKey> StoredKeys = new ArrayList<SecretKey>();
71    public static ArrayList<String> StoredActClasses = new ArrayList<String>();
72    public static ArrayList<String> StoredActUsernames = new ArrayList<String>();
73    public static ArrayList<String> StoredActPasswords = new ArrayList<String>();
74    public static ArrayList<String> StoredActExtras = new ArrayList<String>();
75    public static boolean accountFound = false;  
76    
77    // Main Method
78    public static void main(String[] args) throws Exception {
79        // Show Loading Status UI
80        ServerConnect.displayGUI();
81         try{
82            Class.forName("com.mysql.jdbc.Driver").newInstance();
83            String db_url      = "jdbc:mysql://den1.mysql6.gear.host/csaver";
84            String db_username = "csaver";
85            String db_password = "Hi2T_Tb?fZV6";
86            Connection con = DriverManager.getConnection(db_url, db_username, db_password);
87            //Connection con = DriverManager.getConnection("jdbc:mysql://den1.mysql6.gear.host" + "usercsaver&password=Hi2T_Tb?fZV6&autoReconnect=true&failOverReadOnly=false&maxReconnects=10");
88            String query = "SELECT * FROM accountdata";
89            Statement st = con.createStatement();
90            ResultSet rs = st.executeQuery(query);
91            
92            while(rs.next()){
93               String currentAccount = rs.getString("username");
94               if(currentAccount.equals(computerusername)){
95                   accountFound = true;
96                   break;
97               }
98            }
99            
100            if(accountFound){
101                Thread.sleep(240);
102                ServerConnect.hideGUI();
103                
104                System.out.println("Account found, prompting PIN.");
105                ExistingAccount.displayGUI();
106            }
107            else{
108                Thread.sleep(240);
109                ServerConnect.hideGUI();
110                System.out.println("Account not found, prompting creation.");
111                NewAccount.displayGUI();
112            }
113            con.close();
114        }
115        catch(ClassNotFoundException | IllegalAccessException | InstantiationException | InterruptedException | SQLException e){
116            e.printStackTrace();
117        }
118        // Pull XML File from SQL Server and save locally.
119        
120        // Load XML File and create local storage.
121        try{
122          // Instance a document-builder in order to read file.
123            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
124            factory.setNamespaceAware(false);
125            factory.setValidating(false);
126            DocumentBuilder builder = factory.newDocumentBuilder();
127
128            File file = new File("src/partneredapplication/accountStorage.xml");
129            Document document = builder.parse(file);
130            Element accountStorage = document.getDocumentElement();
131            NodeList accounts = accountStorage.getChildNodes();
132            for(int i = 0, ii = 0, n = accounts.getLength(); i<n; i++){
133                Node child = accounts.item(i);
134                if(child.getNodeType() != Node.ELEMENT_NODE)
135                    continue;
136               Element account = (Element)child;
137               ii++;
138
139               // Add items / attributes to local storage.
140               StoredIds.add(account.getAttribute("id"));
141               StoredUsernames.add(getAccountData(findFirstNamedElement(child,"username")));
142               StoredPins.add(getAccountData(findFirstNamedElement(child,"pin")));
143
144            }
145
146        }  catch(IOException | ParserConfigurationException | SAXException e){
147            e.printStackTrace();
148        }
149
150      // Encryption Example
151
152      /*
153       * SecretKey key = KeyGenerator.getInstance("DES").generateKey();
154       * DesEncrypter encrypter = new DesEncrypter(key);
155       * String encrypted = encrypter.encrypt("1h8f&n101");
156       * String decrypted = encrypter.decrypt(encrypted);
157      */
158
159      /*
160          ServerConnect.hideGUI();
161        
162          // Creates account if one is not created.
163          String computerUsername = System.getProperty("user.name");
164          boolean accountExists = verifyExistance(computerUsername);
165          
166           // Prompt UI in both cases.
167          if(accountExists){
168            System.out.println("Account found, prompting PIN.");
169            ExistingAccount.displayGUI();
170          }
171          else{
172            System.out.println("Account not found, prompting creation.");
173            NewAccount.displayGUI();
174          }
175      */
176
177    }
178    //Hide previous UI
179   
180
181    public static void removeActEntry(String username, String actclass, String actusername, String actpassword, String actextras){
182        String previousActExtras = StoredActExtras.get(returnIndex(username));
183        String previousActUsernames = StoredActUsernames.get(returnIndex(username));
184        String previousActPasswords = StoredActPasswords.get(returnIndex(username));
185        String previousActClasses = StoredActClasses.get(returnIndex(username));
186
187        String editedActExtras = previousActExtras.replaceAll(actextras+"\n", "");
188        String editedActUsernames = previousActUsernames.replaceAll(actusername+"\n", "");
189        String editedActPasswords = previousActPasswords.replaceAll(actpassword+"\n", "");
190        String editedActClasses = previousActClasses.replaceAll(actclass+"\n", "");
191
192        StoredActExtras.set(returnIndex(username), editedActExtras);
193        StoredActClasses.set(returnIndex(username), editedActClasses);
194        StoredActUsernames.set(returnIndex(username), editedActUsernames);
195        StoredActPasswords.set(returnIndex(username), editedActPasswords);
196    }
197
198    // Split compiled information into an array.
199    public static String[] returnSplitInformation(String username, String aclass){
200        if(aclass.equals("usernames")){
201            String compiledData = StoredActUsernames.get(returnIndex(username));
202            String[] splitData = compiledData.split("\n");
203            return splitData;
204        }
205        if(aclass.equals("passwords")){
206            String compiledData = StoredActPasswords.get(returnIndex(username));
207            String[] splitData = compiledData.split("\n");
208            return splitData;
209        }
210        if(aclass.equals("classes")){
211            String compiledData = StoredActClasses.get(returnIndex(username));
212            String[] splitData = compiledData.split("\n");
213            return splitData;
214        }
215        if(aclass.equals("extras")){
216            String compiledData = StoredActExtras.get(returnIndex(username));
217            String[] splitData = compiledData.split("\n");
218            return splitData;
219        }
220        return null;
221    }
222
223    // Prerequisite Verification / 4-Digit Pin Code.
224    public static boolean verifyCredentials(String username, String pin){
225        for(int i=0; i<(StoredUsernames.size()); i++){
226            if(username.equals((String)StoredUsernames.get(i))){
227                if(((String)StoredPins.get(i)).equals(pin)){
228                    //System.out.println("PinCorrectCredentials");
229                    return true;
230                }
231                if(((String)StoredPins.get(i)).equals("NoPin")){
232                    //System.out.println("NoPinCorrectCredentials");
233                    return true;
234                }
235                else{
236                    System.out.println("Incorrect Pin.");
237                    return false;
238                }
239            }
240        }
241        System.out.println("Account does not exist, prompting account creation for "+username);
242        return false;
243    }
244
245    // Add account data entry.
246    public static void addActEntry(String username, String actclass, String actusername, String actpassword, String actextras){
247      if(StoredActExtras.get(returnIndex(username)).equals("")){
248        StoredActExtras.set(returnIndex(username), actextras);
249        StoredActClasses.set(returnIndex(username), actclass);
250        StoredActUsernames.set(returnIndex(username), actusername);
251        StoredActPasswords.set(returnIndex(username), actpassword);
252      }
253      else{
254        StoredActExtras.set(returnIndex(username), StoredActExtras.get(returnIndex(username))+"\n"+actextras);
255        StoredActClasses.set(returnIndex(username), StoredActClasses.get(returnIndex(username))+"\n"+actclass);
256        StoredActUsernames.set(returnIndex(username), StoredActUsernames.get(returnIndex(username))+"\n"+actusername);
257        StoredActPasswords.set(returnIndex(username), StoredActPasswords.get(returnIndex(username))+"\n"+actpassword);
258      }
259    }
260
261    public static int returnIndex(String username){
262      for(int i=0; i<(StoredUsernames.size()); i++){
263        if(username.equals((String)StoredUsernames.get(i))){
264          //System.out.println("Account Exists.");
265          return i;
266        }
267        else{
268          //System.out.println("Account does not exist.");
269          return i;
270        }
271      }
272      return 0;
273    }
274
275    // Verify Existance in case of duplicate prevention.
276    public static boolean verifyExistance(String username){
277        for(int i=0; i<(StoredUsernames.size()); i++){
278          if(username.equals((String)StoredUsernames.get(i))){
279            //System.out.println("Account Exists.");
280            return true;
281          }
282          else{
283            //System.out.println("Account does not exist.");
284            return false;
285          }
286        }
287        return false;
288      }
289
290    // Function for creating account if account is not already created.
291    public static void createAccount(String username, String pin){
292      boolean existingaccount = verifyExistance(username);
293      if(existingaccount == true){
294        return;
295      }
296      else{
297        StoredUsernames.add(username);
298        if(pin != null){
299          StoredPins.add(pin);
300          StoredActUsernames.add("");
301          StoredActPasswords.add("");
302          StoredActClasses.add("");
303          StoredActExtras.add("");
304        }
305        else{
306          StoredPins.add("NoPin");
307          StoredActUsernames.add("");
308          StoredActPasswords.add("");
309          StoredActClasses.add("");
310          StoredActExtras.add("");
311        }
312      }
313    }
314
315    // Find XML Node at the Given Element Name.
316    static private Node findFirstNamedElement(Node parent, String tagName){
317        NodeList children = parent.getChildNodes();
318        for (int i = 0, in = children.getLength(); i<in; i++){
319            Node child = children.item(i);
320             if ( child.getNodeType() != Node.ELEMENT_NODE )
321                continue;
322             if ( child.getNodeName().equals(tagName) )
323                return child;
324        }
325        return null;
326    }
327
328    // Find the Main Node for the Account
329    static private String getAccountData(Node parent){
330        StringBuilder text = new StringBuilder();
331        if(parent == null)
332            return text.toString();
333        NodeList children = parent.getChildNodes();
334        for(int k = 0, kn = children.getLength(); k < kn; k++){
335            Node child = children.item(k);
336            if(child.getNodeType() != Node.TEXT_NODE)
337                break;
338            text.append(child.getNodeValue());
339        }
340        return text.toString();
341    }
342
343    // Clear Local Data for Updating.
344    public static void removeAll(Node node, short nodeType, String name, Object id) {
345
346        if (node.getNodeType() == nodeType && (name == null || node.getNodeName().equals(name))) {
347          Element acID = (Element)node;
348          if(acID.getAttribute("id").equals(id)){
349            node.getParentNode().removeChild(node);
350            }
351        } else {
352          NodeList list = node.getChildNodes();
353          for (int i = 0; i < list.getLength(); i++) {
354            removeAll(list.item(i), nodeType, name, id);
355          }
356        }
357    }
358
359    private static final String ALPHA_NUMERIC_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
360       public static String randomAlphaNumeric(int count) {
361           StringBuilder builder = new StringBuilder();
362       while (count-- != 0) {
363           int character = (int)(Math.random()*ALPHA_NUMERIC_STRING.length());
364           builder.append(ALPHA_NUMERIC_STRING.charAt(character));
365       }
366       return builder.toString();
367    }
368}