[RESOLVED] products images and the extensions allowed

[searain]

For example, I may have 300 products, every product has one and only one image. the image is with the product_code as the image name.

So when I display certain products, I know which images I need to use right away.

I only allow jpg as products images before. No problem so far.

Now if I want allow jpg, gif een png as products images.

Then I run into a problem, say in my master list of the products, I need to display all 300 products.

Now due to I allow jpg, gif or png. Instead directly use the images (such as code11.jpg like before) now, I have to search to whether jpg, gif or png is used, then I can display the image. Additional php process here. If the products are more than hundreds, add a lot of php process.

My questions are

1) search the server for certain file, is this php process heavy or it is nothing even we have to search the files with the foders hundreds times. I should not worry about?

2) what is the general practice, such as for the images of the porducts, we limit it to gif, or we allow free select from gif, jpg, png etc.

Thanks!

[visualAd]

I would build an index the first time the script is ran. The index is then serialized and stored in a file. This is then consulted next time the script is ran. Should you change the file type of one of the files, it wouldn't exist (easily tested); if it does no, we then search and update the index.

Something, i knocked up quikly, hopefully this demonstrates what I mean.

	class ImageIndex
	{
		var $IndexFile = 'img_index.dat';

	var $_index = array();
	var $_dir;

            /* initialize class with the dir containing images */
	function ImageIndex($dir)
	{
		$this->_dir = $dir;

		$this->_loadImageIndex();

		if ($this->_index === false) {
			$this->_createImageIndex();
			$this->_saveimageIndex();
		}

	}

            /* returns the file name with the correct extension appended */
	function GetImagePath($imageName)
	{
		if (array_key_exists($imageName, $this->_index)) {
			$path = $this->_dir . DIRECTORY_SEPARATOR . $imageName . '.' .$this->_index[$imageName];

			if (file_exists($path)) {
				return $imageName . '.' . $this->_index[$imageName];
			} else {
				if (!($ext = $this->_findImageExt($imageName))) { // file has been found with a new extension
					$this->_index[$imageName] = $ext;

					return  $imageName . '.' . $ext;;
				} else { // file has gone
					unset($this->_index[$imageName]);
					return false;
				}
			}
		} else { // ImageName isn't in the index, search for it
			if (! ($ext = $this->_findImageExt($imageName))) {
				$this->_index[$imageName] = $ext;

				 return $imageName . '.' . $ext;
			} else { // Image not found
				return false;
			}
		}
	}

            /* creates the index */
	function _createImageIndex()
	{
		$this->_index = array();

		$dir = opendir($this->_dir);

		while(($item = readdir($dir)) !== false) {
			$path = $this->_dir . DIRECTORY_SEPARATOR . $item;

			if (is_file($path)) {
				/* no extension? ignore this file */
				if (($pos = strpos($item, '.')) === false) continue;

				/* you should include code here to check it is an img file */

				$name = substr($item, 0, $pos);
				$ext =  substr($item, $pos +1);

				$this->_index[$name] = $ext;

			}
		}
	}

	/* searches for an image and returns its extension */
	function _findImageExt($imageName)
	{
		$dir = opendir($this->_dir);

		while(($item = readdir($dir)) !== false) {
			$path = $this->_dir . DIRECTORY_SEPARATOR . $item;

			if (is_file($path)) {
				/* no extension? ignore this file */
				if (($pos = strpos($item, '.')) === false) continue;

				$name = substr($item, 0, $pos);
				$ext =  substr($item, $pos +1);

				if ($name == $imageName) { // file has been found
					return $ext;
				}
			}
		}

		return false;
	}

            /* loads index from file */
	function _loadImageIndex()
	{
		$this->_index = @unserialize(@file_get_contents($this->IndexFile));
	}

            /* saves index to file */
	function _saveimageIndex()
	{
		/* add error handling code here */
		$hwnd = fopen($this->IndexFile, 'w+');

		fwrite($hwnd, serialize($this->_index));			
	}
}

[searain]

For example, I have 300 products, each product will have several images. And these images could be jpg, png, or gif.

I would use http to upload instead of ftp.

1) these files have to be in certain folders, such as I will put all the files for product# 3 in this folder, "productImages/3/". Use ftp the user not just have to switch to ftp sofwarem and also has to remember where to put these files. Too many troubles.
2) plus, in some cases, the ftp uploaded images may have the different ownerships and will not be able to auto delete by php later on.

My questions are

1) will http upload have some troubles if I move the scripts to another platform and say the server administrator may not allow the images folders to be set up as 777? I run into this case once, but it should be rare, just the "server administrator" (a reseller of hosting) doesn't know how to do it and i was not given the shell access to do it by myself. in simple words, http upload should be supported by most hosting platforms, right?

2) if I use http to upload images, should I at the same time, search the images folder for that product, serialized and save it in the database. When in the public interface to display the images of this product, I don't need to search for folder for images, I just need to grab images names from database. - the problem is that if someone ftp/shell delete images, or ftp upload images then there will be broken images links or missing images, because the ftp uploads/deletes will not be recorded in the database? so should I just search the folder each time I want to display images of a product instead?

Thanks!