Initial commit

.gitignore

@@ -0,0 +1,17 @@
+# Eclipse
+.classpath
+.project
+.settings/
+bin/
+
+# Intellij
+.idea/
+*.iml
+*.iws
+
+# Mac
+.DS_Store
+
+# Maven
+log/
+target/

data/accounts.json

@@ -0,0 +1 @@
+[{"firstName":"Dank","lastName":"Memes","history":[{"balanceChange":230,"description":"User deposited 230.0."},{"balanceChange":-12,"description":"User withdrew 12.0."},{"balanceChange":321,"description":"Received 321.0 from Meme Lord."}],"accountNumber":"123456789"},{"firstName":"Meme","lastName":"Lord","history":[{"balanceChange":10000,"description":"User deposited 10000.0."},{"balanceChange":-2103,"description":"User withdrew 2103.0."},{"balanceChange":-321,"description":"Transferred 321.0 to Dank Memes."}],"accountNumber":"987654321"}]

data/backup.json

@@ -0,0 +1 @@
+[{"firstName":"Dank","lastName":"Memes","history":[{"balanceChange":230,"description":"User deposited 230.0."},{"balanceChange":-12,"description":"User withdrew 12.0."}],"accountNumber":"123456789"},{"firstName":"Meme","lastName":"Lord","history":[{"balanceChange":10000,"description":"User deposited 10000.0."},{"balanceChange":-2103,"description":"User withdrew 2103.0."},{"balanceChange":-123,"description":"Transferred 123.0 to K Kman."}],"accountNumber":"987654321"},{"firstName":"Triggered","lastName":"Meme","history":[{"balanceChange":200032,"description":"User deposited 200032.0."},{"balanceChange":2,"description":"User deposited 2.0."}],"accountNumber":"719803"},{"firstName":"K","lastName":"Kman","history":[{"balanceChange":123145,"description":"User deposited 123145.0."},{"balanceChange":-23,"description":"User withdrew 23.0."},{"balanceChange":123,"description":"Received 123.0 from Meme Lord."}],"accountNumber":"105492"}]

pom.xml

@@ -0,0 +1,31 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>eu.tankernn.accountmanager</groupId>
+  <artifactId>eu.tankernn.accountmanager</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <name>Account Manager</name>
+  <description>A super-simple account management system.</description>
+  
+  <dependencies>
+	<!-- https://mvnrepository.com/artifact/org.json/json -->
+	<dependency>
+	    <groupId>org.json</groupId>
+	    <artifactId>json</artifactId>
+	    <version>20160810</version>
+	</dependency>
+  </dependencies>
+  
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.3</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>

src/eu/tankernn/accounts/Account.java

@@ -0,0 +1,75 @@
+package eu.tankernn.accounts;
+
+import java.math.BigInteger;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class Account {
+	
+	private List<AccountEvent> history;
+	private String firstName, lastName, accountNumber;
+
+	public Account(String firstName, String lastName) {
+		do {
+			accountNumber = new BigInteger(20, new SecureRandom()).toString();
+		} while (AccountManager.getAccountByNumber(accountNumber).isPresent());
+		this.firstName = firstName;
+		this.lastName = lastName;
+		this.history = new ArrayList<AccountEvent>();
+	}
+	
+	private Account(String accountNumber, String firstName, String lastName, List<AccountEvent> history) {
+		this(firstName, lastName);
+		this.accountNumber = accountNumber;
+		this.history = history;
+		calculateBalance();
+	}
+
+	public static Account fromJSON(JSONObject obj) throws JSONException {
+		List<AccountEvent> history = new ArrayList<AccountEvent>();
+		
+		JSONArray arr = obj.getJSONArray("history");
+		
+		for (int i = 0; i < arr.length(); i++) {
+			history.add(AccountEvent.fromJSON(arr.getJSONObject(i)));
+		}
+		
+		return new Account(obj.getString("accountNumber"), obj.getString("firstName"), obj.getString("lastName"), history);
+	}
+
+	public String getFirstName() {
+		return firstName;
+	}
+
+	public String getLastName() {
+		return lastName;
+	}
+	
+	public List<AccountEvent> getHistory() {
+		return history;
+	}
+
+	public String getAccountNumber() {
+		return accountNumber;
+	}
+
+	public String toString() {
+		return firstName + " " + lastName;
+	}
+
+	public double calculateBalance() {
+		double newBalance = 0;
+		
+		for (AccountEvent e : history) {
+			newBalance += e.getBalanceChange();
+		}
+		
+		return newBalance;
+	}
+
+}

src/eu/tankernn/accounts/AccountEvent.java

@@ -0,0 +1,37 @@
+package eu.tankernn.accounts;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+public class AccountEvent {
+	
+	private final double balanceChange;
+	private final String description;
+	
+	public AccountEvent(double balanceChange, String description) {
+		this.balanceChange = balanceChange;
+		this.description = description;
+	}
+	
+	public static AccountEvent fromJSON(JSONObject obj) throws JSONException {
+		return new AccountEvent(obj.getDouble("balanceChange"), obj.getString("description"));
+		
+//		if (sender.isPresent() && receiver.isPresent())
+//			return new AccountEvent(sender.get(), receiver.get(), obj.getDouble("amount"));
+//		else
+//			throw new JSONException("The account with account number " + (sender.isPresent() ? obj.getDouble("receiver") : obj.getDouble("sender") + " could not be found."));
+	}
+
+	public double getBalanceChange() {
+		return balanceChange;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+	
+	public String toString() {
+		return description;
+	}
+	
+}

src/eu/tankernn/accounts/AccountManager.java

@@ -0,0 +1,217 @@
+package eu.tankernn.accounts;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import javax.swing.JOptionPane;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import eu.tankernn.accounts.frame.MainFrame;
+import eu.tankernn.accounts.util.Encryption;
+
+public class AccountManager {
+	private static String lastJSONString = "[]";
+	private static String lastPassword;
+	private static boolean saveWithEncryption = false;
+
+	private static List<Account> accounts;
+
+	private static MainFrame window;
+
+	/**
+	 * Initializes the account list using the last file opened, if available.
+	 * Otherwise creates an empty list.
+	 * 
+	 * @param window
+	 *            The <code>MainFrame</code> instance that will be updated once
+	 *            the file has been loaded
+	 */
+	public static void init(MainFrame window) {
+		AccountManager.window = window;
+		accounts = new ArrayList<Account>();
+		openFile(FileManager.getLastFileFromCache());
+	}
+
+	public static void openFile() {
+		openFile(null);
+	}
+
+	/**
+	 * Loads the account file specified.
+	 * 
+	 * @param file
+	 *            The file to load
+	 */
+	public static void openFile(File file) {
+		String rawString = null;
+		try {
+			rawString = FileManager.readFileAsString(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+			return;
+		}
+		if (rawString != null) {
+			String password = null;
+			String jsonString = new String(rawString);
+			while (true) {
+				try {
+					jsonString = password == null ? new String(rawString) : Encryption.decrypt(rawString, password);
+					accounts = parseJSON(jsonString);
+					lastPassword = password;
+					break;
+				} catch (JSONException e) {
+					if (e.getMessage().startsWith("A JSONArray text must start with '['")) {
+						e.printStackTrace();
+						password = JOptionPane.showInputDialog("Invalid JSON, try decrypting it with a password.");
+					} else {
+						e.printStackTrace();
+						break;
+					}
+				}
+			}
+			lastJSONString = jsonString;
+		} else
+			accounts = new ArrayList<Account>();
+		window.refresh();
+	}
+
+	/**
+	 * Clears the account list and creates a new file to write the new accounts
+	 * to.
+	 */
+	public static void newFile() {
+		if (!closeFile())
+			return;
+
+		try {
+			FileManager.newEmptyJSONFile();
+		} catch (IOException e) {
+			e.printStackTrace();
+			return;
+		}
+
+		accounts.clear();
+		lastJSONString = exportJSON();
+	}
+
+	/**
+	 * Saves the current list of accounts to a file.
+	 * 
+	 * @param saveAs
+	 *            Determines whether the user should be prompted to specify a
+	 *            new filename, or if the last filename should be used.
+	 */
+	public static void saveFile(boolean saveAs) {
+		try {
+			String newData = exportJSON();
+			String encryptedData = null;
+			if (saveWithEncryption) {
+				while (lastPassword == null || lastPassword.isEmpty()) {
+					lastPassword = JOptionPane.showInputDialog("Select a password to encrypt the account file with.");
+				}
+				encryptedData = Encryption.encrypt(newData, lastPassword);
+			}
+
+			FileManager.writeStringToFile(saveAs, encryptedData == null ? newData : encryptedData);
+			lastJSONString = newData;
+		} catch (FileNotFoundException e1) {
+			e1.printStackTrace();
+		}
+	}
+
+	/**
+	 * Asks the user to save the current file if any changes have been made.
+	 * 
+	 * @return <code>false</code> if the user clicked cancel. True otherwise.
+	 */
+	public static boolean closeFile() {
+		if (!AccountManager.hasUnsavedChanges()) {
+			return true;
+		} else {
+			int option = JOptionPane.showOptionDialog(null, "Would you like to save changes before exit?",
+					"Save changes", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null, null, 0);
+
+			switch (option) {
+			case JOptionPane.YES_OPTION:
+				try {
+					FileManager.writeStringToFile(false, AccountManager.exportJSON());
+				} catch (FileNotFoundException e) {
+					e.printStackTrace();
+				}
+			case JOptionPane.NO_OPTION:
+				return true;
+			default:
+				return false;
+			}
+		}
+	}
+
+	private static List<Account> parseJSON(String jsonString) throws JSONException {
+		List<Account> parsedAccounts = new ArrayList<Account>();
+
+		JSONArray array = new JSONArray(jsonString);
+
+		for (int i = 0; i < array.length(); i++)
+			parsedAccounts.add(Account.fromJSON(array.getJSONObject(i)));
+
+		return parsedAccounts;
+	}
+
+	/**
+	 * Encodes the current list of accounts into JSON.
+	 * 
+	 * @return The string containing the JSON-encoded string representing the
+	 *         current list of accounts.
+	 */
+	public static String exportJSON() {
+		JSONArray jsonArr = new JSONArray();
+		for (Account a : accounts)
+			jsonArr.put(new JSONObject(a));
+		System.out.println(jsonArr.toString());
+		return jsonArr.toString();
+	}
+
+	public static boolean hasUnsavedChanges() {
+		return !exportJSON().equals(lastJSONString);
+	}
+
+	/**
+	 * Adds the specified account to the list and refreshes the window instance.
+	 * 
+	 * @param account
+	 *            The <code>Account</code> to be added to the list
+	 */
+	public static void addAccount(Account account) {
+		accounts.add(account);
+		window.refresh();
+	}
+
+	public static List<Account> search(String s) {
+		return Arrays.asList(accounts.stream()
+				.filter(a -> a.getAccountNumber().toLowerCase().contains(s) || a.toString().toLowerCase().contains(s))
+				.toArray(Account[]::new));
+	}
+
+	public static List<Account> getAccounts() {
+		return accounts;
+	}
+
+	/**
+	 * Searches the list of accounts for one with the specified account number.
+	 * 
+	 * @param accountNumber
+	 * @return The account, if it was found
+	 */
+	public static Optional<Account> getAccountByNumber(String accountNumber) {
+		return accounts.stream().filter(a -> a.getAccountNumber().equals(accountNumber)).findFirst();
+	}
+
+}

src/eu/tankernn/accounts/FileManager.java

@@ -0,0 +1,114 @@
+package eu.tankernn.accounts;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+
+import javax.swing.JFileChooser;
+import javax.swing.JOptionPane;
+
+public class FileManager {
+	private static final JFileChooser FILE_CHOOSER = new JFileChooser("data/");
+
+	private static final File lastFilenameCache = new File(
+			System.getProperty("user.home") + File.separator + "accountmanager" + File.separator + "lastFile.txt");
+
+	public static File getLastFileFromCache() {
+		// Open last file
+		try {
+			// Create file to cache last filename
+			if (!lastFilenameCache.exists()) {
+				lastFilenameCache.getParentFile().mkdirs();
+				lastFilenameCache.createNewFile();
+				return null;
+			}
+			String lastFilePath = FileManager.readFileAsString(lastFilenameCache);
+			return new File(lastFilePath);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	public static String readFileAsString(File file) throws IOException {
+		if (file == null) {
+			FILE_CHOOSER.showOpenDialog(null);
+			file = FILE_CHOOSER.getSelectedFile();
+		}
+
+		// Remember this filename
+		if (!file.equals(lastFilenameCache))
+			FileManager.writeStringToFile(lastFilenameCache, file.getAbsolutePath());
+		
+		BufferedReader reader = new BufferedReader(new FileReader(file));
+		StringBuilder builder = new StringBuilder();
+
+		while (reader.ready()) {
+			builder.append(reader.readLine());
+		}
+		reader.close();
+
+		return builder.toString();
+	}
+
+	/**
+	 * Creates a new file containing an empty JSON array.
+	 * 
+	 * @return The <code>File</code> object that represents the new file.
+	 * @throws IOException
+	 */
+	public static File newEmptyJSONFile() throws IOException {
+		int result = FILE_CHOOSER.showDialog(null, "Create file");
+		if (result != JFileChooser.APPROVE_OPTION)
+			return null;
+
+		File newFile = FILE_CHOOSER.getSelectedFile();
+
+		if (newFile.exists()) {
+			JOptionPane.showMessageDialog(null, "That file already exists.");
+			return null;
+		}
+		
+		newFile.createNewFile();
+		
+		FileManager.writeStringToFile(lastFilenameCache, newFile.getAbsolutePath());
+		writeStringToFile(newFile, "[]");
+
+		return newFile;
+	}
+	
+	public static void writeStringToFile(boolean saveAs, String contents) throws FileNotFoundException {
+		if (saveAs)
+			FILE_CHOOSER.showSaveDialog(null);
+		writeStringToFile(saveAs ? FILE_CHOOSER.getSelectedFile() : getLastFileFromCache(), contents);
+	}
+
+	public static void writeStringToFile(File file, String contents) throws FileNotFoundException {
+		writeBytesToFile(file, contents.getBytes());
+	}
+
+	public static void writeBytesToFile(File file, byte[] data) throws FileNotFoundException {
+		if (file == null) {
+			FILE_CHOOSER.showSaveDialog(null);
+			file = FILE_CHOOSER.getSelectedFile();
+		}
+
+		FileOutputStream writer = new FileOutputStream(file);
+
+		try {
+			writer.write(data, 0, data.length);
+			writer.flush();
+			writer.close();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	public static File latestFile() {
+		return FILE_CHOOSER.getSelectedFile();
+	}
+}

src/eu/tankernn/accounts/frame/AccountPanel.java

@@ -0,0 +1,160 @@
+package eu.tankernn.accounts.frame;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.swing.DefaultListModel;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.border.TitledBorder;
+
+import eu.tankernn.accounts.Account;
+import eu.tankernn.accounts.AccountEvent;
+import eu.tankernn.accounts.AccountManager;
+
+public class AccountPanel extends JPanel implements ActionListener {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	private Account currentAccount;
+
+	private JPanel infoPanel = new JPanel();
+	private JLabel lName = new JLabel("Name: "), lBalance = new JLabel("Balance: "),
+			lAccountNumber = new JLabel("Account number: ");
+	private JButton transferFrom = new JButton("Transfer from this account..."),
+			deposit = new JButton("Deposit to this account..."),
+			withdraw = new JButton("Withdraw from this account...");
+
+	private JList<AccountEvent> history = new JList<AccountEvent>();
+	private JScrollPane scrollPane = new JScrollPane(history);
+
+	private JComboBox<Account> otherAccounts = new JComboBox<Account>();
+
+	/**
+	 * Create the panel.
+	 */
+	public AccountPanel() {
+		this.setLayout(new BorderLayout());
+
+		infoPanel.setLayout(new GridLayout(6, 1));
+		add(infoPanel, BorderLayout.WEST);
+		infoPanel.add(lName);
+		infoPanel.add(lBalance);
+		infoPanel.add(lAccountNumber);
+
+		infoPanel.add(transferFrom);
+		infoPanel.add(deposit);
+		infoPanel.add(withdraw);
+
+		transferFrom.addActionListener(this);
+		deposit.addActionListener(this);
+		withdraw.addActionListener(this);
+
+		add(scrollPane, BorderLayout.EAST);
+
+		this.setBorder(new TitledBorder("Account panel"));
+	}
+
+	public void updatePanel(Account a) {
+		this.currentAccount = a;
+		
+		if (a == null) {
+			lName.setText("Name: ");
+			lBalance.setText("Balance: ");
+			lAccountNumber.setText("Account number: ");
+			history.setModel(new DefaultListModel<AccountEvent>());
+			
+			transferFrom.setEnabled(false);
+			deposit.setEnabled(false);
+			withdraw.setEnabled(false);
+		} else {
+			lName.setText("Name: " + a.toString());
+			lBalance.setText("Balance: " + a.calculateBalance());
+			lAccountNumber.setText("Account number: " + a.getAccountNumber());
+			history.setModel(GUIUtils.listModelFromList(a.getHistory()));
+			
+			// "Clone" account list
+			List<Account> accounts = new ArrayList<Account>(AccountManager.getAccounts());
+			// Can't transfer to self
+			accounts.remove(a);
+			otherAccounts.setModel(GUIUtils.comboBoxModelFromList(accounts));
+			
+			transferFrom.setEnabled(true);
+			deposit.setEnabled(true);
+			withdraw.setEnabled(true);
+		}
+		
+		// Fix history list width.
+		Dimension d = scrollPane.getPreferredSize();
+		d.width = infoPanel.getWidth(); // Same as infopanel
+		scrollPane.setPreferredSize(d);
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		Object src = e.getSource();
+
+		if (src.equals(transferFrom)) {
+			double amount = showAmountDialog("transfer");
+
+			if (amount <= 0 || amount > currentAccount.calculateBalance()) {
+				JOptionPane.showMessageDialog(null, "Invalid amount.");
+				return;
+			}
+
+			JOptionPane.showConfirmDialog(null,
+					new JComponent[] { new JLabel("Please select receiver account."), otherAccounts }, "Select account.", JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE);
+
+			Account sender = currentAccount, receiver = (Account) otherAccounts.getSelectedItem();
+
+			sender.getHistory().add(new AccountEvent(-amount, "Transferred " + amount + " to " + receiver + "."));
+			receiver.getHistory().add(new AccountEvent(amount, "Received " + amount + " from " + sender + "."));
+		} else if (src.equals(deposit)) {
+			double amount = showAmountDialog("deposit");
+
+			if (amount < 0) {
+				JOptionPane.showMessageDialog(this, "Please enter a positive value.");
+				return;
+			}
+
+			currentAccount.getHistory().add(new AccountEvent(amount, "User deposited " + amount + "."));
+		} else if (src.equals(withdraw)) {
+			double amount = showAmountDialog("withdraw");
+
+			if (amount < 0) {
+				JOptionPane.showMessageDialog(this, "Please enter a positive value.");
+				return;
+			}
+
+			currentAccount.getHistory().add(new AccountEvent(-amount, "User withdrew " + amount + "."));
+		}
+		
+		this.updatePanel(currentAccount);
+	}
+
+	private double showAmountDialog(String action) {
+		String amountStr = JOptionPane.showInputDialog("Amount to " + action + ":");
+
+		double amount = -1;
+		try {
+			amount = Double.parseDouble(amountStr);
+		} catch (NumberFormatException ex) {
+			JOptionPane.showMessageDialog(null, "Please enter a valid number value.");
+		}
+		return amount;
+	}
+}

src/eu/tankernn/accounts/frame/GUIUtils.java

@@ -0,0 +1,23 @@
+package eu.tankernn.accounts.frame;
+
+import java.util.List;
+
+import javax.swing.ComboBoxModel;
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.DefaultListModel;
+
+public class GUIUtils {
+	public static <T> DefaultListModel<T> listModelFromList(List<T> list) {
+		DefaultListModel<T> model = new DefaultListModel<T>();
+		for (T a : list)
+			model.addElement(a);
+		return model;
+	}
+	
+	public static <T> ComboBoxModel<T> comboBoxModelFromList(List<T> list) {
+		DefaultComboBoxModel<T> model = new DefaultComboBoxModel<T>();
+		for (T a : list)
+			model.addElement(a);
+		return model;
+	}
+}

src/eu/tankernn/accounts/frame/MainFrame.java

@@ -0,0 +1,133 @@
+package eu.tankernn.accounts.frame;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.EventQueue;
+import java.awt.LayoutManager;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+
+import javax.swing.JFrame;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTextField;
+import javax.swing.event.DocumentEvent;
+import javax.swing.event.DocumentListener;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import eu.tankernn.accounts.Account;
+import eu.tankernn.accounts.AccountManager;
+import eu.tankernn.accounts.frame.menu.MainMenuBar;
+
+public class MainFrame implements ListSelectionListener, DocumentListener {
+	
+	private JFrame frame;
+	private LayoutManager manager;
+	
+	// Graphics components
+	
+	private MainMenuBar menubar;
+	
+	private JPanel listPanel;
+	private JTextField search;
+	private JList<Account> accounts;
+	private JScrollPane accountScrollPane;
+	
+	private AccountPanel accountPanel;
+
+	/**
+	 * Launch the application.
+	 */
+	public static void main(String[] args) {
+		System.setProperty("apple.eawt.quitStrategy", "CLOSE_ALL_WINDOWS");
+		
+		EventQueue.invokeLater(new Runnable() {
+			public void run() {
+				try {
+					MainFrame window = new MainFrame();
+					AccountManager.init(window);
+					window.refresh();
+					window.frame.setVisible(true);
+				} catch (Exception e) {
+					e.printStackTrace();
+				}
+			}
+		});
+	}
+
+	/**
+	 * Create the application.
+	 */
+	public MainFrame() {
+		initialize();
+	}
+
+	/**
+	 * Initialize the contents of the frame.
+	 */
+	private void initialize() {
+		manager = new BorderLayout();
+		menubar = new MainMenuBar(this);
+		search = new JTextField();
+		accounts = new JList<Account>();
+		
+		frame = new JFrame();
+		frame.setLayout(manager);
+		frame.setJMenuBar(menubar);
+		
+		search.getDocument().addDocumentListener(this);
+		accounts.addListSelectionListener(this);
+		accountScrollPane = new JScrollPane(accounts);
+		accountScrollPane.setPreferredSize(new Dimension(100, 100));
+		frame.add(accountScrollPane, BorderLayout.WEST);
+		
+		
+		accountPanel = new AccountPanel();
+		frame.add(accountPanel, BorderLayout.EAST);
+		
+		frame.setTitle("Account Management System");
+		frame.pack();
+		frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
+		frame.addWindowListener(new WindowAdapter() {
+            public void windowClosing(WindowEvent ev) {
+            	if (AccountManager.closeFile()) {
+            		frame.dispose();
+            	}
+            }
+        });
+	}
+	
+	@Override
+	public void valueChanged(ListSelectionEvent e) {
+		if (accounts.getSelectedValue() != null)
+			accountPanel.updatePanel(accounts.getSelectedValue());
+	}
+
+	public void refresh() {
+		accounts.setModel(GUIUtils.listModelFromList(AccountManager.getAccounts()));
+		accountPanel.updatePanel(null);
+	}
+	
+	private void search() {
+		String s = search.getText();
+		accounts.setModel(GUIUtils.listModelFromList(AccountManager.search(s)));
+	}
+
+	@Override
+	public void insertUpdate(DocumentEvent e) {
+		search();
+	}
+
+	@Override
+	public void removeUpdate(DocumentEvent e) {
+		search();
+	}
+
+	@Override
+	public void changedUpdate(DocumentEvent e) {
+		search();
+	}
+
+}

src/eu/tankernn/accounts/frame/NewAccountDialog.java

@@ -0,0 +1,50 @@
+package eu.tankernn.accounts.frame;
+
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+
+public class NewAccountDialog {
+
+	JLabel lFirstName = new JLabel("First name:"), lLastName = new JLabel("Last name:");
+	JTextField firstName = new JTextField(20), lastName = new JTextField(20);
+	
+	final JComponent[] components = {
+			lFirstName, firstName, lLastName, lastName,
+	};
+	
+	int result;
+
+	/**
+	 * Create the dialog.
+	 */
+	public NewAccountDialog() {
+		result = JOptionPane.showConfirmDialog(null, components, "New Account", JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE);
+	}
+
+	public String getFirstName() {
+		return firstName.getText();
+	}
+
+	public String getLastName() {
+		return lastName.getText();
+	}
+
+	public int getResult() {
+		return result;
+	}
+
+	public boolean validate() {
+		if (result != JOptionPane.OK_OPTION)
+			return false;
+		
+		if (firstName.getText().isEmpty() || lastName.getText().isEmpty()) {
+			JOptionPane.showMessageDialog(null, "Please fill in all the fields.");
+			return false;
+		}
+		
+		return true;
+	}
+
+}

src/eu/tankernn/accounts/frame/menu/MainMenuBar.java

@@ -0,0 +1,84 @@
+package eu.tankernn.accounts.frame.menu;
+
+import java.awt.Event;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.KeyStroke;
+
+import eu.tankernn.accounts.Account;
+import eu.tankernn.accounts.AccountManager;
+import eu.tankernn.accounts.frame.MainFrame;
+import eu.tankernn.accounts.frame.NewAccountDialog;
+
+public class MainMenuBar extends JMenuBar implements ActionListener {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 8702523319236773512L;
+	
+	private MainFrame frame;
+	
+	// Menu Items
+
+	private JMenu fileMenu = new JMenu("File");
+	private JMenuItem newFile = new JMenuItem("New..."), openFile = new JMenuItem("Open..."),
+			saveFile = new JMenuItem("Save"), saveFileAs = new JMenuItem("Save As...");
+
+	private JMenu accountMenu = new JMenu("Accounts");
+	private JMenuItem newAccount = new JMenuItem("New account..."), refresh = new JMenuItem("Refresh accounts");
+
+	public MainMenuBar(MainFrame frame) {
+		this.frame = frame;
+		
+		// File menu
+		addMenuWithItems(fileMenu, newFile, openFile, saveFile, saveFileAs);
+
+		newFile.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, Event.CTRL_MASK));
+		openFile.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O, Event.CTRL_MASK));
+		saveFile.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, Event.CTRL_MASK));
+		saveFileAs.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, Event.CTRL_MASK | Event.SHIFT_MASK));
+
+		// Accounts menu
+		addMenuWithItems(accountMenu, newAccount, refresh);
+
+	}
+
+	private void addMenuWithItems(JMenu menu, JMenuItem... items) {
+		this.add(menu);
+
+		for (JMenuItem item : items) {
+			menu.add(item);
+			item.addActionListener(this);
+		}
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		Object src = e.getSource();
+
+		if (src.equals(newFile)) {
+			AccountManager.newFile();
+		} else if (src.equals(openFile)) {
+			AccountManager.openFile();
+		} else if (src.equals(saveFile)) {
+			AccountManager.saveFile(false);
+		} else if (src.equals(saveFileAs)) {
+			AccountManager.saveFile(true);
+		} else if (src.equals(newAccount)) {
+			NewAccountDialog dialog = new NewAccountDialog();
+			if (dialog.validate()) {
+				AccountManager
+						.addAccount(new Account(dialog.getFirstName(), dialog.getLastName()));
+			}
+		} else if (src.equals(refresh)) {
+			frame.refresh();
+		}
+	}
+
+}

src/eu/tankernn/accounts/util/Encryption.java

@@ -0,0 +1,150 @@
+package eu.tankernn.accounts.util;
+
+import java.io.UnsupportedEncodingException;
+import java.security.AlgorithmParameters;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.InvalidParameterSpecException;
+import java.security.spec.KeySpec;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class Encryption {
+	
+	private static final String CIPHER_TYPE = "AES/GCM/PKCS5Padding";
+	private static final String STRING_SEPARATOR = "#";
+	
+	/**
+	 * Decrypts an encrypted string of data.
+	 * 
+	 * @param dataString
+	 *            A hex-coded string with the format 'SALT#IV#DATA'
+	 * @param password
+	 *            The password used when the string was encoded
+	 * @return The decrypted string
+	 */
+	public static String decrypt(String dataString, String password) {
+		String[] splitted = dataString.split(STRING_SEPARATOR);
+		
+		byte[] salt = hexToBytes(splitted[0]);
+		byte[] iv = hexToBytes(splitted[1]);
+		byte[] data = hexToBytes(splitted[2]);
+
+		return decrypt(salt, iv, data, password);
+	}
+
+	private static String decrypt(byte[] salt, byte[] iv, byte[] data, String key) {
+		try {
+			SecretKey secret = composeKey(salt, key.toCharArray());
+			Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
+			
+			GCMParameterSpec params = new GCMParameterSpec(128, iv);
+			cipher.init(Cipher.DECRYPT_MODE, secret, params);
+			String plainText = new String(cipher.doFinal(data), "UTF-8");
+			return plainText;
+		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException
+				| BadPaddingException | InvalidKeySpecException | UnsupportedEncodingException
+				| InvalidAlgorithmParameterException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	/**
+	 * Encrypts the data using a random salt.
+	 * 
+	 * @param data
+	 *            The data to encrypt.
+	 * @param password
+	 *            The password to use when decrypting the data.
+	 * @return All information needed to get the original data back, except the
+	 *         password, compiled into a single string.
+	 */
+	public static String encrypt(String data, String password) {
+		 byte[][] encryptedComplex = encrypt(new SecureRandom().generateSeed(8), data, password);
+		
+		String saltString = bytesToHex(encryptedComplex[0]);
+		String ivString = bytesToHex(encryptedComplex[1]);
+		String dataString = bytesToHex(encryptedComplex[2]);
+		
+		return String.join(STRING_SEPARATOR, saltString, ivString, dataString);
+	}
+	
+	/**
+	 * Encrypts the data using the key made from the salt and password.
+	 * @param salt
+	 * @param data
+	 * @param password
+	 * @return A two-dimensional byte array where [0] is the salt bytes, [1] is the IV bytes and [2] is the encrypted data bytes.
+	 */
+	private static byte[][] encrypt(byte[] salt, String data, String password) {
+		try {
+			SecretKey secret = composeKey(salt, password.toCharArray());
+			Cipher cipher = Cipher.getInstance(CIPHER_TYPE);
+			cipher.init(Cipher.ENCRYPT_MODE, secret);
+			AlgorithmParameters params = cipher.getParameters();
+			byte[] iv = params.getParameterSpec(GCMParameterSpec.class).getIV();
+			byte[] cipherText = cipher.doFinal(data.getBytes());
+			
+			return new byte[][] {salt, iv, cipherText};
+		} catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException
+				| BadPaddingException | InvalidKeySpecException | InvalidParameterSpecException e) {
+			e.printStackTrace();
+			return null;
+		}
+	}
+
+	private static SecretKey composeKey(byte[] salt, char[] password)
+			throws NoSuchAlgorithmException, InvalidKeySpecException {
+		SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
+		KeySpec spec = new PBEKeySpec(password, salt, 65536, 256);
+		SecretKey tmp = factory.generateSecret(spec);
+		SecretKey secret = new SecretKeySpec(tmp.getEncoded(), "AES");
+		return secret;
+	}
+	
+	/**
+	 * Testing method for encryption functionality.
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		String encrypted = encrypt("asd", "password");
+		System.out.println(encrypted);
+		String decrypted = decrypt(encrypted, "password");
+		System.out.println(decrypted);
+	}
+
+	// Conversion methods, fetched from stackoverflow.com
+
+	final protected static char[] hexArray = "0123456789ABCDEF".toCharArray();
+
+	public static String bytesToHex(byte[] bytes) {
+		char[] hexChars = new char[bytes.length * 2];
+		for (int j = 0; j < bytes.length; j++) {
+			int v = bytes[j] & 0xFF;
+			hexChars[j * 2] = hexArray[v >>> 4];
+			hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+		}
+		return new String(hexChars);
+	}
+
+	public static byte[] hexToBytes(String s) {
+		int len = s.length();
+		byte[] data = new byte[len / 2];
+		for (int i = 0; i < len; i += 2) {
+			data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
+		}
+		return data;
+	}
+}