public interface AvailableForORM{
    public int getID();
    public boolean isExpired();
    public void update();
}



import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import org.postgresql.Driver;
import java.sql.Statement;
import java.sql.ResultSet;
import java.io.BufferedReader;
import java.io.FileReader;

public class Db{
    private Connection c = null;

    public Db(){
        try {
            Class.forName("org.postgresql.Driver");
            BufferedReader i = new BufferedReader(new FileReader("C:\\Users\\Pavel\\Desktop\\smilingRaccoon-master\\resources\\loginData.txt"));
            String s = i.readLine();
            String login = s.substring(0, s.indexOf(" "));
            String password = s.substring(s.indexOf(" ") + 1);

            c = DriverManager
                .getConnection("jdbc:postgresql://localhost:5432/studs",
                login, password);
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println(e.getClass().getName()+": "+e.getMessage());
            System.exit(0);
        }
        System.out.println("Opened database successfully");
    }

    public boolean changePassword(String userName, String newPassword){
        try{
            if(getUserPassword(userName) == null){
                return false;
            }
            Statement stmt = c.createStatement();

            stmt.executeUpdate("update user_data set password='" + newPassword + "' where user_name='" + userName + "';");
            stmt.close();
            return true;
        } catch (SQLException e){
            System.err.println(this + " " + e);
        }
        return false;
    }

    public boolean addUser(String userName, String password, boolean admin){
        checkUserTableExist();


        try{
            Statement stmt = c.createStatement();
            ResultSet rs = stmt.executeQuery("select count(*) from (select * from user_data where user_name='" + userName + "') as a;");

            rs.next();
            if(rs.getInt("count") != 0){
                return false;
            }

            stmt.executeUpdate("insert into user_data (user_name, password, admin) values ('" + userName + "', '" + password + "', " + admin + ");");
            stmt.close();
        } catch (SQLException e){
            System.err.println(this + " " + e);
        }
        return true;
    }

    public String getUserPassword(String userName){

        if(!checkUserTableExist()){
            return null;
        }

        String result = null;

        try{
            Statement stmt = c.createStatement();
            ResultSet rs = stmt.executeQuery( "select password from user_data where user_name='" + userName + "';" );
            while ( rs.next() ) {
                result = rs.getString("password");
            }

            rs.close();
            stmt.close();
        } catch (SQLException e){
            System.err.println(this + " " + e);
        }
        return result;
    }

    public boolean getUserA(String userName){

        if(!checkUserTableExist()){
            return false;
        }

        boolean result = false;

        try{
            Statement stmt = c.createStatement();
            ResultSet rs = stmt.executeQuery( "select admin from user_data where user_name='" + userName + "';" );
            while ( rs.next() ) {
                result = rs.getBoolean(1);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e){
            System.err.println(this + " " + e);
        }
        return result;
    }

    private boolean checkUserTableExist(){
        try{
            Statement stmt = c.createStatement();
            ResultSet rs = stmt.executeQuery( "select count(*) from (select * from pg_tables where tablename='user_data') as a;" );
            rs.next();
            int amount = rs.getInt("count");
            rs.close();
            if(amount == 0){
                stmt.close();
                stmt = c.createStatement();
                stmt.executeQuery( "create table user_data" +
                                   "(id serial primary key, "+
                                   " user_name text not null," +
                                   " password text not null, " +
                                   " admin boolean not null);");
                stmt.close();
                return false;
            } else {
                return true;
            }
        } catch (SQLException e){
            return false;
        }
    }
}





import java.lang.reflect.Field;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.SQLException;
import org.postgresql.Driver;
import java.sql.Statement;
import java.sql.ResultSet;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.*;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class LittleORM{
    private static Connection connection = null;

    static {
        try {
            Class.forName("org.postgresql.Driver");
            BufferedReader i = new BufferedReader(new FileReader("C:\\Users\\Pavel\\Desktop\\smilingRaccoon-master\\resources\\loginData.txt"));
            String s = i.readLine();
            String login = s.substring(0, s.indexOf(" "));
            String password = s.substring(s.indexOf(" ") + 1);

            connection = DriverManager
                .getConnection("jdbc:postgresql://localhost:5432/studs",
                login, password);
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println(e.getClass().getName()+": "+e.getMessage());
            System.exit(0);
        }
        System.out.println("LittleORM has just created a connection to the database!");
    }

    public static String getMD5(String str) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(str.getBytes());
            System.out.println();
            byte[] mdBytes = md.digest();
            StringBuilder sb = new StringBuilder();
            for(int i = 0; i < mdBytes.length; i++) {
                sb.append(Integer.toString((mdBytes[i] & 0xff) + 0x100, 16)
                    .substring(1));
        }
            return sb.toString().trim();
        } catch (NoSuchAlgorithmException exc) {
            return null;
        }
    }

    private static String getTableName(Class objectClass){
        return "t_" + objectClass.getPackage().getName().toLowerCase() + "_" + objectClass.getSimpleName().toLowerCase();
    }
    private static String getTableName(String className){
        return "t_" + className.replace(".", "_").toLowerCase();
    }

    public static boolean checkObjectExist(AvailableForORM object){
        if( !checkTableExist(object.getClass()) ){
            return false;
        }

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery( "select count(*) from ( select * from " + getTableName(object.getClass()) + " where id=" + object.getID() + ") as a;" );
            rs.next();
            if(rs.getInt("count") != 0){
                return true;
            }
            stmt.close();
        } catch (SQLException e) {
            System.err.println(e);
        }
        return false;
    }

    private static boolean checkTableExist(Class objectClass){
        try{

            ResultSet rs = connection.getMetaData()
                .getTables(connection.getCatalog(), null, getTableName(objectClass), null);
            if (!rs.next()) {
                return false;
            }

            //System.out.println(getTableName(objectClass) + " exists");
            rs.close();
        } catch(SQLException e){
            System.out.println("checkTableExist: " + e);
        }
        return true;
    }

    private static boolean checkTableExist(String className){
        try{
            System.out.println(getTableName(className));
            ResultSet rs = connection.getMetaData()
                .getTables(connection.getCatalog(), null, getTableName(className), null);
            if (!rs.next()) {
                return false;
            }

            rs.close();
        } catch(SQLException e){
            System.out.println("checkTableExist: " + e);
        }
        return true;
    }

    private static void createTable(Class objectClass){
        if(checkTableExist(objectClass)){
            //System.out.println("Exist!");
            return;
        }


        String query = "create table " + getTableName(objectClass) + " " +
                       "\n( " +
                       "id integer primary key,\n";

        try{
            for (Field field : objectClass.getDeclaredFields()) {
                field.setAccessible(true);

                String type = field.getGenericType().getTypeName();

                if(type.equals("int") && !field.getName().equals("id")){
                    query = query + field.getName() + " ";
                    query = query + "integer not null,\n";
                } else if (type.equals("double") || type.equals("float")){
                    query = query + field.getName() + " ";
                    query = query + "real not null,\n";
                } else if (type.equals("java.lang.String")){
                    query = query + field.getName() + " ";
                    query = query + "text not null,\n";
                } else if (type.equals("boolean") && !field.getName().equals("isExpired")){
                    query = query + field.getName() + " ";
                    query = query + "boolean not null,\n";
                } else if (type.indexOf(".") > 0){
                    if(!checkTableExist(type)){
                        createTable(Class.forName(type));
                    }
                    query = query + "id_" + field.getName() + " integer references " +
                            "t_" + type.replace(".", "_").toLowerCase() + "(id),\n";

                }

            }
        } catch (Exception e){
            System.err.println("Error was occured while table was being created " + e);
        }

        query = query.substring(0, query.lastIndexOf(","));
        query = query + ");";

        //System.out.println(query);

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            rs.close();
            stmt.close();
        } catch (SQLException e){
            //System.err.println(e);
        }
    }

    private static int getNextID(Class objectClass){
        try(Statement stmt = connection.createStatement()){
            ResultSet rs = stmt.executeQuery("select count(*) from (select * from " + getTableName(objectClass) + " ) as a;");
            rs.next();
            return rs.getInt("count") + 1;

        } catch (SQLException e){
            System.err.println(e);
        }

        return 1;
    }

    public static AvailableForORM createObject(Class objectClass, ArrayList<Object> list){
        if(objectClass == null){
            System.err.println("ObjectClass is null");
            return null;
        }

        boolean canBeUsed = false;
        for(Class temp : objectClass.getInterfaces()){
            if(temp.getName().equals("DB.AvailableForORM")){
                canBeUsed = true;
            }
        }
        if(!canBeUsed){
            return null;
        }

        if(!checkTableExist(objectClass)){
            createTable(objectClass);
        }

        String query = "insert into " + getTableName(objectClass) + "\n" +
                "values ( " ;

        AvailableForORM object = null;
        try{
            object = (AvailableForORM)objectClass.newInstance();
        } catch (InstantiationException|IllegalAccessException e) {
            System.err.println(e);
            return null;
        }

        int object_id = getNextID(objectClass);
        try{
            boolean id = false;
            for (Field field : object.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                String type = field.getGenericType().getTypeName();

                //System.out.println(list.get(0).getClass().getTypeName());
                if(!id){
                    query = query + " " + object_id + ", ";
                    field.set(object, object_id);
                    id = true;
                    continue;
                }

                if(field.getName().equals("isExpired")){
                    continue;
                }

                //System.out.println(field.getName());
                if(type.equals("int") && list.get(0).getClass().getTypeName().equals("java.lang.Integer")){
                    query = query +  " " + (Integer)list.get(0) + ", ";
                    field.set(object, list.get(0));
                } else if ((type.equals("double") || type.equals("float")) && list.get(0).getClass().getTypeName().equals("java.lang.Double")){
                    query = query +  " " + (Double)list.get(0) + ", ";
                    field.set(object, list.get(0));
                } else if (type.equals("java.lang.String") && list.get(0).getClass().getTypeName().equals("java.lang.String")){
                    query = query +  " '" + (String)list.get(0) + "', ";
                    field.set(object, list.get(0));
                } else if (type.equals("boolean") && list.get(0).getClass().getTypeName().equals("java.lang.Boolean")){
                    query = query +  " " + (Boolean)list.get(0) + ", ";
                    field.set(object, list.get(0));
                } else if (type.indexOf(".") > 0){
                    if(!checkTableExist(type)){
                        createTable(Class.forName(type));
                    }
                    AvailableForORM temp = createObject(Class.forName(type), list);

                    query = query + " " + temp.getID() + ", ";
                    field.set(object, temp);
                }
                if(list.size() > 0){
                    list.remove(0);
                }
            }
        } catch (Exception e){
            System.err.println("Error was occured while table was being created " + e);
        }

        query = query.substring(0, query.lastIndexOf(","));
        query = query + ");";

        //System.out.println(query);

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            rs.close();
            stmt.close();
        } catch (SQLException e){
            //System.err.println(e);
        }

        return object;
    }

    public static boolean removeObject(AvailableForORM object){
        if(object.isExpired() || !checkObjectExist(object)){
            return false;
        }

        try{
            for (Field field : object.getClass().getDeclaredFields()) {
                field.setAccessible(true);

                String type = field.getGenericType().getTypeName();

                if (type.indexOf(".") > 0){
                    removeObject((AvailableForORM)field.get(object));
                }
            }
        } catch (Exception e){
        }

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery( "delete from " + getTableName(object.getClass()) + " where id=" + object.getID() +";" );
            stmt.close();
        } catch (SQLException e) {
            return false;
        }
        return true;
    }

    public static boolean updateObject(AvailableForORM object){
        if(!checkObjectExist(object)){
            return false;
        }

        String query = "update " + getTableName(object.getClass()) + " set \n";

        try{
            for (Field field : object.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                String type = field.getGenericType().getTypeName();

                if(field.getName().equals("isExpired")){
                    continue;
                }

                if(type.equals("int") && !field.getName().equals("id")){
                    query = query +  " " + field.getName() + "=" + (Integer)field.get(object) + ", ";
                } else if ((type.equals("double") || type.equals("float"))){
                    query = query +  " " + field.getName() + "=" + (Double)field.get(object)+ ", ";
                } else if (type.equals("java.lang.String")){
                    query = query +  " " + field.getName() + "='" + (String)field.get(object) + "', ";
                } else if (type.equals("boolean")){
                    query = query +  " " + field.getName() + "=" + (Boolean)field.get(object) + ", ";
                } else if (type.indexOf(".") > 0){
                    query = query + " " + ((AvailableForORM)field.get(object)).getID() + ", ";
                }
            }
        } catch (Exception e){
            System.err.println("Error was occured while table was being created " + e);
            return false;
        }
        query = query.substring(0, query.lastIndexOf(","));
        query = query + " where id=" + object.getID() + ";";

        //System.out.println(query);

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery(query);
            rs.close();
            stmt.close();
        } catch (SQLException e){
            //System.err.println(e);
        }

        return true;
    }

    public static AvailableForORM loadObject(Class objectClass, int id){
        if(!checkTableExist(objectClass)){
            return null;
        }
        AvailableForORM object = null;
        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery("select * from " + getTableName(objectClass) + " where id=" + id + ";");
            try{
                object = (AvailableForORM)objectClass.newInstance();
            } catch (InstantiationException|IllegalAccessException e) {
                System.err.println(e);
                return null;
            }

            int i = 1;
            while(rs.next()) {
                for(Field field : object.getClass().getDeclaredFields()){
                    field.setAccessible(true);
                    String type = field.getGenericType().getTypeName();

                    if(field.getName().equals("isExpired")){
                        field.set(object, false);
                        continue;
                    }

                    if(type.equals("int")){
                        field.set(object, rs.getInt(i));
                        i++;
                    } else if (type.equals("double") || type.equals("float")){
                        field.set(object, rs.getDouble(i));
                        i++;
                    } else if (type.equals("java.lang.String")){
                        field.set(object, rs.getString(i));
                        i++;
                    } else if (type.equals("boolean")){
                        field.set(object, rs.getBoolean(i));
                        i++;
                    } else if (type.indexOf(".") > 0){
                        AvailableForORM temp = loadObject(Class.forName(type), rs.getInt(i));
                        i++;
                        field.set(object, temp);
                    }
                }
            }
        } catch (Exception e){
            System.err.println("Error was occured while table was being created " + e);
        }
        return object;
    }

    public static int getObjectsAmount(Class objectClass){
        if(!checkTableExist(objectClass)){
            return 0;
        }

        try{
            Statement stmt = connection.createStatement();
            ResultSet rs = stmt.executeQuery( "select count(*) from ( select * from " + getTableName(objectClass) + ") as a;" );
            rs.next();
            return rs.getInt(1);
        } catch (SQLException e) {
            System.err.println(e);
        }

        return 0;
    }
}



import java.lang.reflect.Field;

public class User implements AvailableForORM{
    private int id;
    private boolean admin;
    private UserProperties prop;
    private boolean isExpired = false;

    public int getID(){
        return id;
    }

    public void update(){
        this.isExpired = !LittleORM.checkObjectExist(this);
        // from base
    }

    public boolean isAdmin(){
        update();
        return admin;
    }

    public void setName(String name){
        if(isExpired){
            return;
        }
        prop.setName(name);
        LittleORM.updateObject(this);
    }

    public String getName(){
        update();
        return prop.getName();
    }

    public boolean isExpired(){
        update();
        return isExpired;
    }

    public void setPassword(String password){
        prop.setPassword(password);
        LittleORM.updateObject(this);
    }

    public boolean isPassword(String password){
        update();
        if(isExpired){
            return false;
        }
        return prop.isPassword(password);
    }

    public User(){
        ;
    }

    public User(boolean admin, String name, String password){
        prop = new UserProperties(name, password);
        this.admin = admin;

    }
}



public class UserProperties implements AvailableForORM{
    private int id;
    private String name;
    private String password;
    private boolean isExpired = false;

    public UserProperties(){
        ;
    }

    public UserProperties(String name, String password){
        this.name = name;
        this.password = password;
    }

    public void update(){
        this.isExpired = !LittleORM.checkObjectExist(this);
        // from base
    }

    public void setPassword(String password){
        this.password = password;
        LittleORM.updateObject(this);
    }

    public boolean isExpired(){
        update();
        return isExpired;
    }

    public int getID(){
        return id;
    }

    public void setName(String name){
        this.name = name;
        LittleORM.updateObject(this);
    }

    public String getName(){
        update();
        return name;
    }

    public boolean isPassword(String password){
        update();
        return this.password.equals(password);
    }

}