package com.masoomyf;
import java.io.*;
import java.util.*;
public class Main {
//To store all bicycle parts.
private static ArrayList<BicyclePart> bicycleParts;
//flag if changes is made in database or not.
//if yes save it.
private static boolean databaseUpdated = false;
//main database file.
private static File wareHouseFile;
public static void main(String[] args) {
//initialize new ArrayList.
//Array list is use instead of array because it is expandable as
//well as it will collapse after deleting object.
bicycleParts = new ArrayList<>();
//Creating File object of database file.
wareHouseFile = new File("wareHouseDb.txt");
//for reading user input.
Scanner inputReader = new Scanner(System.in);
//Now check database file exists or not.
//If there is no Bicycle parts in database, or user run it first time
//Its return false, because there will be no database file.
if(wareHouseFile.exists()){
// file is exists, try to read it.
try {
//reading main file.
//Creating file input stream to read file. and passing File object
//of database txt file.
FileInputStream inputStream = new FileInputStream(wareHouseFile);
//Creating buffered reader for file input stream.
//It's allow to read file line by line and many more options.
//but we need only to read line by line.
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
//Creating String line, for storing each line of database file.
String line;
//loop until there is no new line available in database file.
//If there is no new line its return null and while loop breaks.
while ((line=reader.readLine())!=null){
//check whether line is empty or not.
//if line is empty get next line.
if(line.isEmpty()){
continue;
}
//If line is not empty perform the following.
//get new line from file and add it to bicycle.
//create new bicycle part and add it to arrayList.
BicyclePart bicyclePart = BicyclePart.getPartFromString(line);
bicycleParts.add(bicyclePart);
}
}catch (Exception ignore){
//If we get any error during reading file.
//output error message.
System.out.println("Cant read ware house database.");
}
}
//Now display these option, until user write quit.
while (true){
//It will useful when user chooses an option another that quit,
//It allow user to read the previous message of console.
System.out.println("Press any key to continue.....");
//It will not continue until user press any button and enter.
inputReader.nextLine();
//User pressed enter, it means user read the previous information.
//Now display menu again(or first time).
System.out.println("Please select your option from the following menu:");
System.out.println("Read: Read an inventory delivery file");
System.out.println("Enter: Enter a part");
System.out.println("Sell: Sell a part");
System.out.println("Display: Display a part");
System.out.println("SortName: Sort parts by part name");
System.out.println("SortNumber: Sort parts by part number");
System.out.println("Quit:");
System.out.print("Enter your choice: ");
//Now read the choice of user.
String choice = inputReader.nextLine();
//According to choice call the appropriate option.
if(choice.equalsIgnoreCase("read")){
readFile(inputReader);
}
else if(choice.equalsIgnoreCase("enter")){
enterPart(inputReader);
}
else if(choice.equalsIgnoreCase("sell")){
sellPart(inputReader);
}
else if(choice.equalsIgnoreCase("display")){
displayPart(inputReader);
}
else if(choice.equalsIgnoreCase("sortName")){
sortByName();
}
else if(choice.equalsIgnoreCase("sortNumber")){
sortByNumber();
}
else if(choice.equalsIgnoreCase("quit")){
//If user select quit.
//save the database and break the loop.
saveDatabase();
break;
}
else {
//If user writes another option other than provided menu.
//Give this error.
System.out.println("Invalid option chosen.");
}
}
}
//Reading file inventory.txt.
//Passing scanner here, so we don't need to create again a new scanner.
private static void readFile(Scanner inputReader) {
//prompt user to enter file name i.e. inventory.txt.
System.out.println("Enter file name to read from: ");
//read the fileName.
String fileName = inputReader.nextLine();
//Pass the filename to new File object.
//It will allow to check whether file is exists or not.
File file = new File(fileName);
//If file not exists display error message and return from this method.
if(!file.exists()){
System.out.println("Error: File not exists.");
return;
}
//If file exists try the following.
try {
//Create a new scanner by passing file object of inventory.txt
//You can choose buffered reader also.
//Just learn new thing.
Scanner fileReader = new Scanner(file);
//Marking this line as nextLine.
//For future use.
nextLine:
//check if there is new line by looping.
while (fileReader.hasNextLine()){
//New line present, read the new line and store it into line.
String line = fileReader.nextLine();
//Now create a new Bicycle part.
BicyclePart temp = BicyclePart.getPartFromString(line);
//Now check, if this part exists in bicycleArrayList(database)
//by comparing the temp part number with every bicycle part's number
//store in array list(database)
for (BicyclePart bicyclePart:bicycleParts){
//Check if bicycle part is present or not.
if(temp.id==bicyclePart.id){
//Yes present.
//Update it with new details, available in temp.
bicyclePart.listPrice = temp.listPrice;
bicyclePart.salePrice = temp.salePrice;
bicyclePart.onSale = temp.onSale;
//Add the quantity.
bicyclePart.quantity += temp.quantity;
//Flag the databaseUpdated to true.
//means save the database on exit, because it gets changed.
databaseUpdated = true;
//we use continue nextLine here because if we use only
//continue, for loop get's continue, and we don't it.
//so just skip the for loop and continue the while loop
//without executing the below lines.
//Below line is for new part's that are not available
//in our database.
continue nextLine;
}
}
//If there is no part that matches the temp, that's mean
//part is new and add it to database.
bicycleParts.add(temp);
//Flag the databaseUpdated to true.
//means save the database on exit, because it gets changed.
databaseUpdated=true;
}
}catch (Exception e){
//If something happen wrong, output the error.
System.out.println("Error: " + e.getMessage());
}
}
private static void enterPart(Scanner inputReader) {
//Prompt and read all parts info from user.
System.out.print("Enter part name: ");
String name = inputReader.nextLine();
//Below extra inputReader.nextLine is used because, we read a datatype
//other than string.
//If we don't call extra nextLine method, after reading this if we read a
//string, it will give us a new line.
//Example: we have to read an integer.
//we use inputReader.nextInteger().
//After that user write 45 or any number and press enter.
//45 passed to caller, and enter remains in scanner, and we try to read new
//line in future, it will just pass the enter which is in scanner.
//rather than wait for a new string user will enter.
System.out.print("Enter part number: ");
long id = inputReader.nextLong();
inputReader.nextLine();
System.out.print("Enter list price: ");
double listPrice = inputReader.nextDouble();
inputReader.nextLine();
System.out.print("Enter sell price: ");
double salePrice = inputReader.nextDouble();
inputReader.nextLine();
System.out.print("Part is on sale? [true/false]: ");
boolean onSale = inputReader.nextBoolean();
inputReader.nextLine();
System.out.println("Enter quantity: ");
int quantity = inputReader.nextInt();
inputReader.nextLine();
//Now first check if bicycle part enter by user is present
//in database or not. If yes update it and stop the method execution.
for (BicyclePart bicyclePart: bicycleParts){
if(bicyclePart.id == id){
bicyclePart.listPrice = listPrice;
bicyclePart.salePrice = salePrice;
bicyclePart.onSale = onSale;
bicyclePart.quantity += quantity;
System.out.println("Bicycle part updated.");
databaseUpdated = true;
return;
}
}
//If not add the new part to database.
BicyclePart bicyclePart = new BicyclePart(id,name,listPrice,salePrice,onSale,quantity);
bicycleParts.add(bicyclePart);
System.out.println("New bicycle part is added.");
databaseUpdated = true;
}
//For selling part.
private static void sellPart(Scanner inputReader) {
System.out.println("Enter part number: ");
//Get the partNumber.
long partNumber = inputReader.nextLong();
//Remove the extra enter comes with long.
inputReader.nextLine();
//Check part enter by user is present in database or not.
for (BicyclePart part: bicycleParts){
if(partNumber == part.id){
//if yes call sellPart(BicyclePart),
//this method is also sellPart but with different signature
//i.e. sellPart(Scanner).
sellPart(part);
//and stop executing this method.
return;
}
}
//If part is present then this line never execute.
//If not present, this line will execute.
//And show error message.
System.out.println("Error: Bicycle part not exists.");
}
private static void sellPart(BicyclePart part){
//check quantity is not less than one.
//if yes give the error and stop execution of this method.
if(part.quantity < 1){
System.out.println("Error: No quantity left.");
return;
}
//If quantity is more than zero(means available)
//Print the part name and its cost.
System.out.println("Part Name: " + part.name);
// here tertiary operator is used for taking decision in line.
// (true|false ? if true : if false)
System.out.println("Part Cost: " + (part.onSale?part.salePrice:part.listPrice));
if(part.onSale){
System.out.println("Part is on sale.");
}
//Display the current date.
System.out.println("Sold Time: " + new Date().toString());
//decrease the part quantity.
part.quantity--;
//change the flag to true.
//if it changes by another method, no problem.
databaseUpdated=true;
}
//For displaying part.
private static void displayPart(Scanner inputReader) {
System.out.print("Enter part name: ");
//read part name.
//here no extra inputReader.nextLine() is use because string is read.
//it automatically read the string with new line and omit it.
String partName = inputReader.nextLine();
//loop through database bicycle array list and check whether part name
//is available or not.
for (BicyclePart part: bicycleParts){
if(partName.equalsIgnoreCase(part.name)){
//if available call displayPart(BicyclePart) method.
displayPart(part);
//return.
return;
}
}
//if no part is available display the error.
System.out.println("Error: Bicycle part not exists.");
}
//simple displayPart method.
private static void displayPart(BicyclePart part) {
System.out.println("Part Name: " + part.name);
System.out.println("Part Cost: " + (part.onSale?part.salePrice:part.listPrice));
}
//sortByName method.
private static void sortByName() {
//sort the arraylist with the help of new Comparator.
//java has compare option for datatype pre-defined in java,
//If we create a new datatype(i.e. class), we have to implement and override the compare
//method.
bicycleParts.sort(new Comparator<BicyclePart>() {
@Override
public int compare(BicyclePart o1, BicyclePart o2) {
//Compare the Bicycle Name with another one.
//Java has string compare method.
//so we use here and return the compare value to Comparator.
return o1.name.compareToIgnoreCase(o2.name);
}
});
//Now simply print all parts avail in database.
System.out.println("Sorted part names: ");
for (BicyclePart bicyclePart: bicycleParts){
System.out.println(bicyclePart.name);
}
}
//same as above but, here only change is that arraylist is sort by it's part number
private static void sortByNumber() {
bicycleParts.sort(new Comparator<BicyclePart>() {
@Override
//Compare with part number.
public int compare(BicyclePart o1, BicyclePart o2) {
return Long.compare(o1.id,o2.id);
}
});
//Print the sorted arrayList.
System.out.println("Sorted part names: ");
for (BicyclePart bicyclePart: bicycleParts){
System.out.println(bicyclePart.name);
}
}
private static void saveDatabase() {
//Check databaseUpdated flag.
//If it is false, means no method execute which change the current database.
//Therefore no need to save it.
//return back.
if(!databaseUpdated)return;
//if it is true. write it to file.
//first write it to temp file.
//then delete the old database file.
//after that rename the temp file to database file.
try {
//Create file output stream to write the data.
FileOutputStream outputStream = new FileOutputStream("temp.txt");
//create buffered writer to write line by line.
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream));
//loop through all part available in array list(database)
for (BicyclePart bicyclePart:bicycleParts){
//write the bicycle part to file follow with a new line.
//bicycle.toString is defined in BicyclePart.java
//which gives whole thing in string with comma seperator.
writer.write(bicyclePart.toString() + "\n");
}
//close the writer.
writer.close();
//close output stream.
outputStream.close();
//check if the old database file actually exists or not.
//if exists delete it.
if(wareHouseFile.exists())
wareHouseFile.delete();
//create a file object with name temp.txt
File file = new File("temp.txt");
//rename it to database file.
file.renameTo(wareHouseFile);
}catch (Exception ignore){
//rise error if anything happens wrong.
ignore.printStackTrace();
}
}
}
