Program/WebServer/Directory.cpp

#include "Directory.h"
#include "../../String/StringInput.h"
#include "../../System/System.h"
#include "../../DateTime/DateTime.h"
#include "../../System/SystemDefine.h"
#include "../../Html/Table.h"
#include "../../Html/Link.h"
#include "../../Files/FileHandler.h"
#include "../../Files/FileInfo.h"


Directory::Directory(Header *iHeader)
{
        columnToSort=0;
        fileMatris=null;
        buttonMatris=null;
        header=iHeader;
        readPermission=true;
        
        linkFileName = new Link();
        linkFileSize = new Link();
        linkFileType = new Link();
        linkLastModified = new Link();

        linkFileName->info->setString("Name");
        linkFileSize->info->setString("Size");
        linkFileType->info->setString("Type");
        linkLastModified->info->setString("LastModified");
}

Directory::~Directory()
{
        if (linkFileName!=null)
        {
                delete linkFileName;
        }

        if (linkFileSize!=null)
        {
                delete linkFileSize;
        }

        if (linkFileType!=null)
        {
                delete linkFileType;
        }

        if (linkLastModified!=null)
        {
                delete linkLastModified;
        }
}

void Directory::createFileMatris()
{
        fileMatris = new HtmlMatrisList<String>(4);
        
        String filePath=header->filePath;
        String path=header->filePathWithoutRootPath;

        FileHandler fileHandler;

        ObjectLinkedList<FileInfo> *fileList=fileHandler.listDirectory(filePath);

        int size=fileList->size();

        for ( int i=0; i<size ; i++ )
        {
                FileInfo *fileInfo=fileList->getElement(i);

                Link link;

                String fileName;

                if (!filePath.isBackPartEqualTo("/"))
                {
                        fileName+=path;
                        fileName+="/";
                }

                fileName+=fileInfo->name;

                if (fileInfo->directory)
                {
                        link.filePath->setString(fileName + "/");
                }
                else
                {
                        link.filePath->setString(fileName);
                }

                link.info->setString(fileInfo->name);
                link.create();

                fileMatris->addColumnInRow(link, fileInfo->name, 0);

                if (fileInfo->directory)
                {
                        fileMatris->addColumnInRow("***", 1);
                        fileMatris->addColumnInRow("Directory", 2);
                }
                else
                {
                        String fileSize=fileInfo->size;
//                      String fileSize="10000";
                        fileMatris->addColumnInRow(fileSize, 1);
                        fileMatris->addColumnInRow("File", 2);
                }

                fileMatris->addColumnInRow(fileInfo->lastModified, 3);

                fileMatris->addRow();
        }       

        delete fileList;

        if(linkFileName->filePath->equals("?NameUp"))
        {
                columnToSort=0;
                fileMatris->sortColumnInLargestOrder(columnToSort);
                return;
        }

        if(linkFileName->filePath->equals("?NameDown"))
        {
                columnToSort=0;
                fileMatris->sortColumnInSmallestOrder(columnToSort);
                return;
        }

        if(linkFileSize->filePath->equals("?SizeUp"))
        {
                columnToSort=1;
                fileMatris->sortColumnInLargestValueOrder(columnToSort);
                return;
        }

        if(linkFileSize->filePath->equals("?SizeDown"))
        {
                columnToSort=1;
                fileMatris->sortColumnInSmallestValueOrder(columnToSort);
                return;
        }

        if(linkFileType->filePath->equals("?TypeUp"))
        {
                columnToSort=2;
                fileMatris->sortColumnInLargestOrder(columnToSort);
                return;
        }

        if(linkFileType->filePath->equals("?TypeDown"))
        {
                columnToSort=2;
                fileMatris->sortColumnInSmallestOrder(columnToSort);
                return;
        }

        if(linkLastModified->filePath->equals("?LastModifiedUp"))
        {
                columnToSort=3;
                fileMatris->sortColumnInLargestOrder(columnToSort);
                return;
        }

        if(linkLastModified->filePath->equals("?LastModifiedDown"))
        {
                columnToSort=3;
                fileMatris->sortColumnInSmallestOrder(columnToSort);
                return;
        }

}

void Directory::createButtonMatris() 
{
        linkFileName->create();
        linkFileSize->create();
        linkFileType->create();
        linkLastModified->create();

        buttonMatris = new HtmlMatrisList<String>(4);
        
        buttonMatris->addColumnInRow(linkFileName, "1", 0);
        buttonMatris->addColumnInRow(linkFileSize, "1", 1);
        buttonMatris->addColumnInRow(linkFileType, "1", 2);
        buttonMatris->addColumnInRow(linkLastModified, "1",  3);


        buttonMatris->addRow();
}

bool Directory::init()
{
        bool connectionStatus=true;

        createFileMatris();
        createButtonMatris();

        String start;

//      start.readFile("Html/Start.txt");

        Table table;
        table.border=1;
        table.width=400;
        table.createMatris(buttonMatris);
        table.createMatris(fileMatris, columnToSort);
        table.create();


        String data=start + "<html><body><form>" + table.data + "</form></body></html>";
//      System::println(data);

        connectionStatus=header->makeAndSendHeaderWithStringData(data);

        if (fileMatris != null)
        {
                delete fileMatris;
        } 

        if (buttonMatris != null)
        {
                delete buttonMatris;
        }

        return connectionStatus;
}


bool Directory::check()
{
        String filePath=header->filePath;

//part 1

        if (filePath.isBackPartEqualTo("/?Name"))
        {
                linkFileName->filePath->setString("?NameDown");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?Size"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?SizeDown");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?Type"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?TypeDown");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?LastModified"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModifiedDown");

                return checkIfThatIsADirectory(filePath);
        }

//part 2

        if (filePath.isBackPartEqualTo("/?NameDown"))
        {
                linkFileName->filePath->setString("?NameUp");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");
                
                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?SizeDown"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?SizeUp");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?TypeDown"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?TypeUp");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?LastModifiedDown"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModifiedUp");

                return checkIfThatIsADirectory(filePath);
        }

//part 3

        if (filePath.isBackPartEqualTo("/?NameUp"))
        {
                linkFileName->filePath->setString("?NameDown");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");
                
                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?SizeUp"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?SizeDown");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?TypeUp"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?TypeDown");
                linkLastModified->filePath->setString("?LastModified");

                return checkIfThatIsADirectory(filePath);
        }

        if (filePath.isBackPartEqualTo("/?LastModifiedUp"))
        {
                linkFileName->filePath->setString("?Name");
                linkFileSize->filePath->setString("?Size");
                linkFileType->filePath->setString("?Type");
                linkLastModified->filePath->setString("?LastModifiedDown");

                return checkIfThatIsADirectory(filePath);
        }

        FileHandler fileHandler;
        FileInfo *fileInfo=fileHandler.getFileInfo(filePath);

        if (fileInfo->directory)
        {
                String path;

                if (!filePath.isBackPartEqualTo("/"))
                {
                        path+=header->filePathWithoutRootPath;
                        path+="/";
                }

                linkFileName->filePath->setString(path + "?Name");
                linkFileSize->filePath->setString(path + "?Size");
                linkFileType->filePath->setString(path + "?Type");
                linkLastModified->filePath->setString(path + "?LastModified");
        
                readPermission=fileInfo->readPermission;
//              System::println("directory");
                return true;
        }
        else
        {
//              System::println("not a directory");
                return false;
        }

        return false;
}


bool Directory::checkIfThatIsADirectory(String &filePath)
{
        filePath.cutTheBegining('/');
        filePath+="/";
        header->filePath->setString(filePath);

        FileHandler fileHandler;
        FileInfo *fileInfo=fileHandler.getFileInfo(filePath);

        if (fileInfo->directory)
        {
                readPermission=fileInfo->readPermission;
                return true;
        }
        else
        {
                readPermission=fileInfo->readPermission;
                return false;
        }

        return false;
}
1	#include "Directory.h"
2	#include "../../String/StringInput.h"
3	#include "../../System/System.h"
4	#include "../../DateTime/DateTime.h"
5	#include "../../System/SystemDefine.h"
6	#include "../../Html/Table.h"
7	#include "../../Html/Link.h"
8	#include "../../Files/FileHandler.h"
9	#include "../../Files/FileInfo.h"
10
11
12	Directory::Directory(Header *iHeader)
13	{
14	columnToSort=0;
15	fileMatris=null;
16	buttonMatris=null;
17	header=iHeader;
18	readPermission=true;
19
20	linkFileName = new Link();
21	linkFileSize = new Link();
22	linkFileType = new Link();
23	linkLastModified = new Link();
24
25	linkFileName->info->setString("Name");
26	linkFileSize->info->setString("Size");
27	linkFileType->info->setString("Type");
28	linkLastModified->info->setString("LastModified");
29	}
30
31	Directory::~Directory()
32	{
33	if (linkFileName!=null)
34	{
35	delete linkFileName;
36	}
37
38	if (linkFileSize!=null)
39	{
40	delete linkFileSize;
41	}
42
43	if (linkFileType!=null)
44	{
45	delete linkFileType;
46	}
47
48	if (linkLastModified!=null)
49	{
50	delete linkLastModified;
51	}
52	}
53
54	void Directory::createFileMatris()
55	{
56	fileMatris = new HtmlMatrisList<String>(4);
57
58	String filePath=header->filePath;
59	String path=header->filePathWithoutRootPath;
60
61	FileHandler fileHandler;
62
63	ObjectLinkedList<FileInfo> *fileList=fileHandler.listDirectory(filePath);
64
65	int size=fileList->size();
66
67	for ( int i=0; i<size ; i++ )
68	{
69	FileInfo *fileInfo=fileList->getElement(i);
70
71	Link link;
72
73	String fileName;
74
75	if (!filePath.isBackPartEqualTo("/"))
76	{
77	fileName+=path;
78	fileName+="/";
79	}
80
81	fileName+=fileInfo->name;
82
83	if (fileInfo->directory)
84	{
85	link.filePath->setString(fileName + "/");
86	}
87	else
88	{
89	link.filePath->setString(fileName);
90	}
91
92	link.info->setString(fileInfo->name);
93	link.create();
94
95	fileMatris->addColumnInRow(link, fileInfo->name, 0);
96
97	if (fileInfo->directory)
98	{
99	fileMatris->addColumnInRow("***", 1);
100	fileMatris->addColumnInRow("Directory", 2);
101	}
102	else
103	{
104	String fileSize=fileInfo->size;
105	// String fileSize="10000";
106	fileMatris->addColumnInRow(fileSize, 1);
107	fileMatris->addColumnInRow("File", 2);
108	}
109
110	fileMatris->addColumnInRow(fileInfo->lastModified, 3);
111
112	fileMatris->addRow();
113	}
114
115	delete fileList;
116
117	if(linkFileName->filePath->equals("?NameUp"))
118	{
119	columnToSort=0;
120	fileMatris->sortColumnInLargestOrder(columnToSort);
121	return;
122	}
123
124	if(linkFileName->filePath->equals("?NameDown"))
125	{
126	columnToSort=0;
127	fileMatris->sortColumnInSmallestOrder(columnToSort);
128	return;
129	}
130
131	if(linkFileSize->filePath->equals("?SizeUp"))
132	{
133	columnToSort=1;
134	fileMatris->sortColumnInLargestValueOrder(columnToSort);
135	return;
136	}
137
138	if(linkFileSize->filePath->equals("?SizeDown"))
139	{
140	columnToSort=1;
141	fileMatris->sortColumnInSmallestValueOrder(columnToSort);
142	return;
143	}
144
145	if(linkFileType->filePath->equals("?TypeUp"))
146	{
147	columnToSort=2;
148	fileMatris->sortColumnInLargestOrder(columnToSort);
149	return;
150	}
151
152	if(linkFileType->filePath->equals("?TypeDown"))
153	{
154	columnToSort=2;
155	fileMatris->sortColumnInSmallestOrder(columnToSort);
156	return;
157	}
158
159	if(linkLastModified->filePath->equals("?LastModifiedUp"))
160	{
161	columnToSort=3;
162	fileMatris->sortColumnInLargestOrder(columnToSort);
163	return;
164	}
165
166	if(linkLastModified->filePath->equals("?LastModifiedDown"))
167	{
168	columnToSort=3;
169	fileMatris->sortColumnInSmallestOrder(columnToSort);
170	return;
171	}
172
173	}
174
175	void Directory::createButtonMatris()
176	{
177	linkFileName->create();
178	linkFileSize->create();
179	linkFileType->create();
180	linkLastModified->create();
181
182	buttonMatris = new HtmlMatrisList<String>(4);
183
184	buttonMatris->addColumnInRow(linkFileName, "1", 0);
185	buttonMatris->addColumnInRow(linkFileSize, "1", 1);
186	buttonMatris->addColumnInRow(linkFileType, "1", 2);
187	buttonMatris->addColumnInRow(linkLastModified, "1", 3);
188
189
190	buttonMatris->addRow();
191	}
192
193	bool Directory::init()
194	{
195	bool connectionStatus=true;
196
197	createFileMatris();
198	createButtonMatris();
199
200	String start;
201
202	// start.readFile("Html/Start.txt");
203
204	Table table;
205	table.border=1;
206	table.width=400;
207	table.createMatris(buttonMatris);
208	table.createMatris(fileMatris, columnToSort);
209	table.create();
210
211
212	String data=start + "<html><body><form>" + table.data + "</form></body></html>";
213	// System::println(data);
214
215	connectionStatus=header->makeAndSendHeaderWithStringData(data);
216
217	if (fileMatris != null)
218	{
219	delete fileMatris;
220	}
221
222	if (buttonMatris != null)
223	{
224	delete buttonMatris;
225	}
226
227	return connectionStatus;
228	}
229
230
231	bool Directory::check()
232	{
233	String filePath=header->filePath;
234
235	//part 1
236
237	if (filePath.isBackPartEqualTo("/?Name"))
238	{
239	linkFileName->filePath->setString("?NameDown");
240	linkFileSize->filePath->setString("?Size");
241	linkFileType->filePath->setString("?Type");
242	linkLastModified->filePath->setString("?LastModified");
243
244	return checkIfThatIsADirectory(filePath);
245	}
246
247	if (filePath.isBackPartEqualTo("/?Size"))
248	{
249	linkFileName->filePath->setString("?Name");
250	linkFileSize->filePath->setString("?SizeDown");
251	linkFileType->filePath->setString("?Type");
252	linkLastModified->filePath->setString("?LastModified");
253
254	return checkIfThatIsADirectory(filePath);
255	}
256
257	if (filePath.isBackPartEqualTo("/?Type"))
258	{
259	linkFileName->filePath->setString("?Name");
260	linkFileSize->filePath->setString("?Size");
261	linkFileType->filePath->setString("?TypeDown");
262	linkLastModified->filePath->setString("?LastModified");
263
264	return checkIfThatIsADirectory(filePath);
265	}
266
267	if (filePath.isBackPartEqualTo("/?LastModified"))
268	{
269	linkFileName->filePath->setString("?Name");
270	linkFileSize->filePath->setString("?Size");
271	linkFileType->filePath->setString("?Type");
272	linkLastModified->filePath->setString("?LastModifiedDown");
273
274	return checkIfThatIsADirectory(filePath);
275	}
276
277	//part 2
278
279	if (filePath.isBackPartEqualTo("/?NameDown"))
280	{
281	linkFileName->filePath->setString("?NameUp");
282	linkFileSize->filePath->setString("?Size");
283	linkFileType->filePath->setString("?Type");
284	linkLastModified->filePath->setString("?LastModified");
285
286	return checkIfThatIsADirectory(filePath);
287	}
288
289	if (filePath.isBackPartEqualTo("/?SizeDown"))
290	{
291	linkFileName->filePath->setString("?Name");
292	linkFileSize->filePath->setString("?SizeUp");
293	linkFileType->filePath->setString("?Type");
294	linkLastModified->filePath->setString("?LastModified");
295
296	return checkIfThatIsADirectory(filePath);
297	}
298
299	if (filePath.isBackPartEqualTo("/?TypeDown"))
300	{
301	linkFileName->filePath->setString("?Name");
302	linkFileSize->filePath->setString("?Size");
303	linkFileType->filePath->setString("?TypeUp");
304	linkLastModified->filePath->setString("?LastModified");
305
306	return checkIfThatIsADirectory(filePath);
307	}
308
309	if (filePath.isBackPartEqualTo("/?LastModifiedDown"))
310	{
311	linkFileName->filePath->setString("?Name");
312	linkFileSize->filePath->setString("?Size");
313	linkFileType->filePath->setString("?Type");
314	linkLastModified->filePath->setString("?LastModifiedUp");
315
316	return checkIfThatIsADirectory(filePath);
317	}
318
319	//part 3
320
321	if (filePath.isBackPartEqualTo("/?NameUp"))
322	{
323	linkFileName->filePath->setString("?NameDown");
324	linkFileSize->filePath->setString("?Size");
325	linkFileType->filePath->setString("?Type");
326	linkLastModified->filePath->setString("?LastModified");
327
328	return checkIfThatIsADirectory(filePath);
329	}
330
331	if (filePath.isBackPartEqualTo("/?SizeUp"))
332	{
333	linkFileName->filePath->setString("?Name");
334	linkFileSize->filePath->setString("?SizeDown");
335	linkFileType->filePath->setString("?Type");
336	linkLastModified->filePath->setString("?LastModified");
337
338	return checkIfThatIsADirectory(filePath);
339	}
340
341	if (filePath.isBackPartEqualTo("/?TypeUp"))
342	{
343	linkFileName->filePath->setString("?Name");
344	linkFileSize->filePath->setString("?Size");
345	linkFileType->filePath->setString("?TypeDown");
346	linkLastModified->filePath->setString("?LastModified");
347
348	return checkIfThatIsADirectory(filePath);
349	}
350
351	if (filePath.isBackPartEqualTo("/?LastModifiedUp"))
352	{
353	linkFileName->filePath->setString("?Name");
354	linkFileSize->filePath->setString("?Size");
355	linkFileType->filePath->setString("?Type");
356	linkLastModified->filePath->setString("?LastModifiedDown");
357
358	return checkIfThatIsADirectory(filePath);
359	}
360
361	FileHandler fileHandler;
362	FileInfo *fileInfo=fileHandler.getFileInfo(filePath);
363
364	if (fileInfo->directory)
365	{
366	String path;
367
368	if (!filePath.isBackPartEqualTo("/"))
369	{
370	path+=header->filePathWithoutRootPath;
371	path+="/";
372	}
373
374	linkFileName->filePath->setString(path + "?Name");
375	linkFileSize->filePath->setString(path + "?Size");
376	linkFileType->filePath->setString(path + "?Type");
377	linkLastModified->filePath->setString(path + "?LastModified");
378
379	readPermission=fileInfo->readPermission;
380	// System::println("directory");
381	return true;
382	}
383	else
384	{
385	// System::println("not a directory");
386	return false;
387	}
388
389	return false;
390	}
391
392
393	bool Directory::checkIfThatIsADirectory(String &filePath)
394	{
395	filePath.cutTheBegining('/');
396	filePath+="/";
397	header->filePath->setString(filePath);
398
399	FileHandler fileHandler;
400	FileInfo *fileInfo=fileHandler.getFileInfo(filePath);
401
402	if (fileInfo->directory)
403	{
404	readPermission=fileInfo->readPermission;
405	return true;
406	}
407	else
408	{
409	readPermission=fileInfo->readPermission;
410	return false;
411	}
412
413	return false;
414	}