XBv78ueR

1package controller;
2
3import java.io.File;
4import java.util.ArrayList;
5import java.util.HashSet;
6import java.util.List;
7import java.util.Set;
8
9import javax.script.ScriptException;
10
11import model.ClassFactory;
12import model.Database;
13import model.DatabaseFilterGenerator;
14import model.DatabaseHelper;
15import model.Observer;
16import model.Record;
17import model.Table;
18import util.App;
19import util.BooleanEvaluator;
20
21public class DatabaseController implements DBMS, Observer {
22    private DBMSController dbmsController;
23    private DatabaseHelper dbHelper;
24    private DatabaseFilterGenerator databaseFilter;
25    private ClassFactory classFactory;
26
27    public DatabaseController(DBMSController dbmsController) {
28        databaseFilter = new DatabaseFilterGenerator();
29        ClassFactory classFactory = new ClassFactory();
30        this.dbmsController = dbmsController;
31        dbHelper = new DatabaseHelper(this);
32    }
33
34    public DatabaseHelper getHelper() {
35        return dbHelper;
36    }
37
38    @Override
39    public void update() {
40        // TODO Auto-generated method stub
41    }
42
43    @Override
44    public boolean useDatabase(String databaseName) {
45        File usedDatabase = getDatabase(databaseName);
46        if (usedDatabase == null) {
47            // throw new RuntimeException("Database doesnot exist");
48            return false;
49        }
50        dbHelper.getCurrentDatabase().useDatabase(usedDatabase);
51        reLoadTables(dbHelper.getCurrentDatabase());
52        return true;
53    }
54
55    @Override
56    public boolean createDatabase(String databaseName) {
57        if (databaseExists(databaseName)) {
58            return false;
59        }
60        new Database(dbHelper.getWorkSpacePath(), databaseName);
61        return true;
62    }
63
64    @Override
65    public boolean createTable(String tableName, List<String> colNames, List<Class<?>> types) {
66        if (colNames.size() != types.size() || containsDublicates(colNames)) {
67            throw new RuntimeException("Wrong data entered");
68        }
69        if (tableExists(tableName)) {
70            throw new RuntimeException("Table already exists");
71        }
72        File tableFile = new File(
73                dbHelper.getCurrentDatabase().getPath() + File.separator + tableName);
74        Table table = new Table(tableFile);
75        dbHelper.getCurrentDatabase().registerTable(table);
76        File xmlFile = dbmsController.getXMLController().initializeXML(table.getTablePath(),
77                tableName, colNames, types);
78        File dtdFile = dbmsController.getXMLController().initializeDTD(table.getTablePath(),
79                tableName, colNames, types);
80        table.registerFiles(xmlFile, dtdFile);
81        return true;
82    }
83
84    @Override
85    public boolean dropTable(String tableName) {
86        int index = 0;
87        for (Table table : dbHelper.getCurrentDatabase().getTables()) {
88            if (table.getTableName().equals(tableName)) {
89                deleteDir(table.getTableDir());
90                dbHelper.getCurrentDatabase().getTables().remove(index);
91                return true;
92            }
93        }
94        return false;
95    }
96
97    @Override
98    public boolean dropDatabase(String databaseName) {
99        File database = getDatabase(databaseName);
100        if (database == null) {
101            return false;
102        }
103        deleteDir(database);
104        return true;
105    }
106
107    @Override
108    public boolean insertIntoTable(String tableName, List<String> colNames, List<Object> values) {
109        if (colNames.size() != values.size()) {
110            return false;
111        }
112        List<String> typesAsStrings = dbmsController.getXMLController().getTypes();
113        // Loop and validate.
114        List<Class<?>> types = getTypesFromStrings(typesAsStrings);
115        List<Object> generateValues = new ArrayList<>();
116        // Loop through classes and create record.
117        Record record = new Record(generateValues);
118        Table table = getTable(tableName);
119        return dbmsController.getXMLController().insertIntoTable(table, record);
120    }
121
122    @Override
123    public boolean insertIntoTable(String tableName, List<Object> values) {
124        // read classes names to validate.
125        Record record = new Record(values);
126        Table table = getTable(tableName);
127        return dbmsController.getXMLController().insertIntoTable(table, record);
128    }
129
130    @Override
131    public boolean selectFromTable(String tableName, List<String> colNames, String condition) {
132
133        return false;
134    }
135
136    @Override
137    public boolean updateTable(String tableName, List<String> colNames, List<Object> values,
138            String condition) {
139        return false;
140    }
141
142    @Override
143    public boolean deleteFromTable(String tableName, List<String> colNames, String condition) {
144        return false;
145    }
146
147    private Table getTable(String tableName) {
148        for (Table table : dbHelper.getCurrentDatabase().getTables()) {
149            if (table.getTableName().equals(tableName)) {
150                return table;
151            }
152        }
153        return null;
154    }
155
156    private List<Class<?>> getTypesFromStrings(List<String> typesAsString) {
157        List<Class<?>> types = new ArrayList<>();
158        for (int i = 0; i < typesAsString.size(); i++) {
159            types.add(classFactory.getClass(typesAsString.get(i)));
160        }
161        return types;
162    }
163
164    private <T> boolean containsDublicates(List<T> list) {
165        Set<T> temp = new HashSet<>(list);
166        if (temp.size() != list.size()) {
167            return true;
168        }
169        return false;
170    }
171
172    private boolean databaseExists(String databaseName) {
173        File database = getDatabase(databaseName);
174        if (database == null) {
175            return false;
176        }
177        return true;
178    }
179
180    private boolean tableExists(String tableName) {
181        for (Table table : dbHelper.getCurrentDatabase().getTables()) {
182            if (table.getTableName().equals(tableName)) {
183                return true;
184            }
185        }
186        return false;
187    }
188
189    private void deleteDir(File file) {
190        File[] contents = file.listFiles();
191        if (contents != null) {
192            for (File f : contents) {
193                deleteDir(f);
194            }
195        }
196        file.delete();
197    }
198
199    private File getDatabase(String databaseName) {
200        File[] databases = dbHelper.getDatabaseDir().listFiles(databaseFilter);
201        for (File databaseFile : databases) {
202            if (databaseFile.getName().equals(databaseName)) {
203                return databaseFile;
204            }
205        }
206        return null;
207    }
208
209    private void reLoadTables(Database database) {
210        database.clearTableList();
211        File[] tables = database.getDatabaseDir().listFiles(databaseFilter);
212        for (File tableDir : tables) {
213            Table table = new Table(tableDir);
214            File xmlFile = new File(
215                    table.getTablePath() + File.separator + table.getTableName() + ".xml");
216            File dtdFile = new File(
217                    table.getTablePath() + File.separator + table.getTableName() + ".dtd");
218            if (!(xmlFile.exists() && dtdFile.exists())) {
219                throw new RuntimeException("Missing table files");
220            }
221            table.registerFiles(xmlFile, dtdFile);
222            database.getTables().add(new Table(tableDir));
223        }
224    }
225
226    private boolean evaluate(String expression, Record record) throws ScriptException {
227        String exp = getFilledExpression(expression, record);
228        exp = exp.toLowerCase();
229        exp = App.replace(exp, "and", " && ");
230        exp = App.replace(exp, "or", " || ");
231        exp = App.replace(exp, "not", " ! ");
232        return BooleanEvaluator.evaluate(exp);
233    }
234
235    private String getFilledExpression(String expression, Record record) {
236        String exp = expression;
237        for (int i = 0; i < record.getColumns().size(); i++) {
238            if (record.getValues().get(i) instanceof String) {
239                exp = App.replace(exp, record.getColumns().get(i).toLowerCase(),
240                        "\"" + record.getValues().get(i).toString() + "\"");
241            } else {
242                exp = App.replace(exp, record.getColumns().get(i).toLowerCase(),
243                        record.getValues().get(i).toString());
244            }
245        }
246        return exp;
247    }
248}