Problem Statement
So I do iTop Development ( A open source service desk software) .
While implementing a feature I got stuck on how to upload a file to the server directory but thanks to this stackoverflow question I was able to upload the file in my local machine with a project structure to test the feature. The minimal viable project went like this : -
./
├── index.html
├── index.js
├── upload.php
└── uploads
├── ocr.png
└── ocr_prev_ui.png
and I used the same code that was specified in that question.
But when I put that same code in an already existing extension itop-attachments to add a field that would upload a temp file which gets deleted after an ocr operation is run, It throws the following error:
I even Searched the same question on sourceforge (Error: Unknown class ''.)
But it seems that it does not apply to my case.
Replication
Try make a custom form that uploads file in the /var/www/html/tbitsm/env-production/itop-attachments directory, using this code :
$oPage->add('<fieldset>');
$oPage->add('<legend>OCR Attachment</legend>');
$oPage->add('<div id="AttachmentsContent">');
$oPage->add('<form id="ocr_form" action="'.utils::GetAbsoluteUrlAppRoot().'/env-production/itop-attachments/test.php" method="POST" enctype="multipart/form-data">');
$oPage->add('<label for="OCR">Upload Image to Scan for OCR (png,jpg,jpeg):</label>');
$oPage->add('<br>');
$oPage->add('<br>');
<-- This is where the Error is -->
$oPage->add('<input type="file" id="OCR" name="OCR" accept="image/png, image/jpeg">');
$oPage->add('<input type="submit" value="Upload OCR"/>');
<-- Outputs -->
<--Fatal error, iTop cannot continue. -->
<--Error: Unknown class ''.-->
$oPage->add('</form>');
$oPage->add('</fieldset>');
Now, Make an incident in iTop and attach a image in the newly created OCR Attachment formset
Now click upload.
You will see the same Issue as I do .
Footnote
Environment :
Ubuntu 20.04 ,
Apache 2.4,
PHP 7.4.3 ,
iTop 2.7
I am not able to solve this issue. Likely seems a PHP or iTop Speicific issue where it cannot find class="Incident" . I am not sure.
I have an old legacy project and I am trying to upgrade it to Laravel framework.
So far I have installed the laravel into the www directory of my existing project and changing the project one page at a time.
Following is my directory structure.
MyProject
├── uploaded_files
├── www
│ ├── index.php
│ ├── images
│ ├── beta (Laravel Project)
That is how everything is structured. So my new laravel project url is myproject.com/beta/public for now.
Anyway, my concern is that all the existing uploaded files exists in uploaded_files directory and some in www->images directory.
How can I access those files from beta (Laravel) directory so that I can display them and also create new files when necessary.
So far I have tried to access the images directly from the main url but it doesnt work and also tried to create a symlink directly with uploaded_files but that doesnt work either.
How can I access the files from MyProject=> Uploaded files in Laravel controller?
Thank you.
Is there any standard project structure for Composer projects such as the Maven's Standard Directory Layout in PHP?
The newest answer is "yes", based on scanning every package listed on https://packagist.org and counting which directories are being used by the vast majority of packages, i.e. what most people unconsciously agreed upon without coordination:
https://github.com/php-pds/skeleton
The short summary for directories:
If a package has a root-level directory for ...
... then it MUST be named:
command-line executables bin/
configuration files config/
documentation files docs/
web server files public/
other resource files resources/
PHP source code src/
test code tests/
Using this layout pretty much aligns your project with every other project you'd probably use as dependency. Note that you do not have to have EVERY directory, only the ones that actually host files.
The typical layout is this:
src/
vendor/
.git
composer.json
composer.lock
For compatibility purposes, the Git and Composer files should sit in the root of the project.
The source directory should be the root of the source files beginning with the top level namespace of your classes.
The vendor directory should contain all third party libraries imported via composer.
This is the minimum expected standards, particularly for a live project environment. If the project is a library, then the source directory could be omited.
The best example of this is the Symfony2 Standard Edition:
https://github.com/symfony/symfony-standard
After this the convention for frontend assets and controller is normally:
web/
js/
css/
images/
index.php
The index file in this case is your front controller.
This should include a bootstrapper in another directory, or initialize the environment using the configuration in that directory.
For Symfony2 this is the app directory:
https://github.com/symfony/symfony-standard/tree/master/app
Hope this helps, bare in mind this is based solely on my experience and observations.
I'm having problems with Symfony. I recently got a Symfony project and I'm having problems moving a Symfony project from a server with Cpanel to a virtual server on Wamp. I haven't used Symfony before so I'm really confused on how the whole project would be opened in like a tree structure so that i can see whats going on.
Symfony's file structure is as such:
apps/
frontend/
backend/
batch/
cache/
config/
data/
sql/
doc/
lib/
model/
log/
plugins/
test/
unit/
functional/
web/
css/
images/
js/
uploads/
I presume you do not have access to the repository so you'll have to copy all the files to your WAMP installation. Generally you do not need to copy over the cache/* and log/* files. After copying the whole project to WAMP you can see if it's still working by running ./symfony.bat or ./symfony on linux/unix/osx.
Best way to copy the whole project is by creating an archive first, then extract it into your WAMP installation. In order to create tar.gz/zip/rar/tar.bz backups follow these steps:
Log in your cPanel and go to the File Manager;
In the left box, navigate to the directory / files you'd like to archive. Mark the items to be archived in the left box and choose "Compress" from the top menu
I am creating a very large PHP MVC-based site that will have a large library of php classes, javascripts, and many css files (not to mention a large amount of files for the MVC).
For the first time ever, I am actually taking the time to plan out a clean and organized directory structure.
What directory structures do you typically use, and which will be easiest to manuever when there are thousands of files?
This is my setup. It's worked great for me for small - very large projects (including a social network).
These folders would all live within my main application folder:
config - contains custom PHP config files
css - contains the project's CSS files
helpers - contains 'helper' files (each file is a collection of functions)
images - contains the project's images
js - contains the project's Javascript files
lib - contains PHP classes specific to the project
modules - My MVC framework allows packaging site sections as modules
blog - An example module
controllers - contains the controllers for the module
models - contains the models for the module
views - contains the views for the module
views - contains views that should be globally accessible (page header, footer, etc)
All the directories could obviously contain sub-folders that would further organize your files. For example, the 'css' folder could have sub-folders named 'web' and 'mobile'. The 'images' folder could contain a 'user_uploaded' folder which could then contain`'profile'. And of course you can add folders as you see fit, in one project I have a folder called 'uploaders' which just contains stand-alone upload scripts.
I also use convenience methods which help construct the filenames of what I want to load. For example, my loadView() will look for the view file in the current module directory, or if you pass an optional $module argument, it will look specifically within that module's folder.
I hope this helps.
You should have one directory as web root, where only files you want exposed to the whole internet should reside.
project/
web/
index.php
css/
js/
images/
config/
lib/
web/ is the root shown to visitors
lib/ is here the library folder, and where autoload look for files.
You can add more subfolders to project/ like controller, modules, view, helper, etc. This depends on your framework.
EDIT:
If you use composer (which I recommend) and maybe npm with grunt and less your file structure would be the following:
project/
web/
js/
css/
images/
index.php
cli/
config/
config.php
node_modules/
src/
test/
vendor/
composer.json
composer.lock
packages.json
web/ has all your public files
cli/ scripts and programs to be run from command line NOT the web
config/ has all your config files (in git you ignore config.php and instead have config.dist.php without usernames, passwords, validation codes and table prefixes/suffixes and other "secrets")
node_modules/ has all your library files from npm (in git I suggest you put this in a submodule)
src has all your local PHP files in psr4 structure, set up to autoload in composer.json
test/ has all your unit tests for your src classes, set up in autload-dev in composer.json (remember to use composer install --no-dev on live, maybe add -o if you don't have too many classes)
vendor has all your library files from composer and the ONE AND ONLY autoload.php to be included in web/index.php and any cli scripts (in git I suggest you ignore this vendor folder)
Add other folders and files as required for your project.
For deployment use this structure:
/sites/project/ (project is your projectname)
current (alias to current release folder releases/v1.1.0)
previous (optional alias to previous release folder releases/v1.0.1)
releases/
v1.0.0/ (git checkout of tag v1.0.0)
v1.0.1/ (git checkout of tag v1.0.1)
v1.1.0/ (git checkout of tag v1.1.0)
shared/ (has all your shared files and folders to be aliased in all releases - maybe something like GlusterFS)
Make a deployment script. Something like this:
First take backup of db or to copy it to a new database, checkout git repo to new folder with release tag, get all git submodules, run composer install --no-dev, setup any aliases for shared folders and files like uploaded images and configuration files, generate js/css with grunt and less or equivalent, point current alias to the new folder with the tag, run update database script, restart nginx/apache/fpm-php services, run tests to check the website is up.
Have a script to go back to previous version (or a guide so you know what to do).
For core files which are included:
approot/inc/
For data access functions and classes are in:
approot/dao/
For javascripts:
approot/scripts/
For CSS:
approot/styles/
For images:
approot/img/
For static content (normally for user profile pictures or uploaded images):
approot/static/
For caches:
approot/caches/
For templates or View files:
approot/templates/
All pages file:
approot/
Structure from Samstyle PHP Framework
The answer I posted here was from 2009. Over the years more standards were published, including PSR-0 which covers the topic on folder structure. I also have a new (and I feel that it's better) folder structure with Packfire Framework.
In my experience, you can never plan for this. You can try to follow what frameworks do, but I find I never quite fit exactly into their mold.
I recommend to just keep a good rule of thumb for 20 files in a directory maximum. If you find you need more, just create a few sub directories and move common components in there.
This is mostly a matter of preference, a quick Google search would reveal many different project structures. But it would be really nice if there were an agreed upon standard. I think this initiative by the PHP Package Development Standards is a good candidate.
This is the directory structure they propose:
bin/: command-line executables
config/: configuration files
docs/: documentation files
public/: web server files
resources/: other resource files
src/: PHP source code
tests/: test code
EDIT:
This is also mentioned in the PHP The Right Way under the section Common Directory structure.
I use codeigniter for small and big projects.
It's MVC feature is moderately good.
codeIgniter\system\application\config : contain all kind of configuration files like DB,Payment gateway, ftp config, routes and ...
codeIgniter\system\application\models: contain all kinds of database classes, you should create sub folders according to your need, I used customers, mailData, paymentModel, report, web-service and ....
codeIgniter\system\application\views: contain all kinds of files that will work as output for clients, you should think of reuse these files if possible. Like the models you had to create sub folder like administration, reports, email, email_template .....
codeIgniter\system\application\controllers : this is the most important part. This will help to create SEO url, so you should be more careful about sub folders this time. You can create like administration, products, reports, orders..... and consider a good name for the functions of the controller class.
These were for the PHP/HTML file.
Now about the other files:
codeIgniter\images: for the images
codeIgniter\scripts: for the Java scripts and their framework
codeIgniter\styles: for the CSS
codeIgniter\uploads: for the uploaded files, if you don't want to put files in the DB
For the detail see codeIgniter framework in detail.
Here "codeIgniter\" is the approot
This is the structure i'm using currently,
public/
assets/ /* js, css, imgs, ... */
index.php
src/
config/ /* for config files */
helpers/ /* for functions */
libraries/ /* for free classes that are not MVC classes */
models/ /* for M in MVC */
views/ /* for V in MVC */
controllers/ /* for C in MVC */
vendor/ /* for vendors files */
uploads/ /* for uploaded images, docs, ... */
Have a look at symfony 1.4 or symfony 2 dir structure. Choose what's most intuitive to you.
I believe this depends on how large the project will become. This is what I used mostly:
project/
index.php
img/
css/
js/
views/
functions/
As long as all the project files are organised...
Even though the question is abit old, I still think it is wise to suggest the latest scaleable application structure which I have been working in my SOA based application and working absolutely fine.
myApplication/
app/
config/
+ this can include custom MVC structure
cli/
docker/
lib/ - most commonly reusable components
logs/
public/ - should contain all publicly exposable web contains
sql/ - db migration stuffs
tests/ - compulsory test
tools/ - application addon tools like any kinds of rulset etc
vendor/