شركة التطبيقات المتكاملة لتصميم النظم البرمجية الخاصة

Integrated Applications Programming Company

Skip Navigation LinksHome » Code Library » Upload

Public general use code classes and xml files that we've compiled and used over the years:

Handle file uploading functions.

   1:  using System;
   2:  using System.IO;
   3:  using System.Web;
   4:   
   5:  namespace Ia.Cl.Model
   6:  {
   7:      ////////////////////////////////////////////////////////////////////////////
   8:   
   9:      /// <summary publish="true">
  10:      /// Handle file uploading functions.
  11:      /// </summary>
  12:      /// <value>
  13:      /// Make sure you set permissions for IUSR and IWP to Read and Write for upload directory.
  14:      /// </value>
  15:      /// <remarks> 
  16:      /// Copyright � 2001-2016 Jasem Y. Al-Shamlan (info@ia.com.kw), Integrated Applications - Kuwait. All Rights Reserved.
  17:      ///
  18:      /// This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
  19:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  20:      ///
  21:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  22:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  23:      /// 
  24:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  25:      /// 
  26:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  27:      /// </remarks> 
  28:      public class Upload
  29:      {
  30:          ////////////////////////////////////////////////////////////////////////////
  31:   
  32:          /// <summary>
  33:          ///
  34:          /// </summary>
  35:          public Upload() { }
  36:   
  37:          ////////////////////////////////////////////////////////////////////////////
  38:   
  39:          /// <summary>
  40:          ///
  41:          /// </summary>
  42:          public static string FileName
  43:          {
  44:              get
  45:              {
  46:                  HttpFileCollection hfc = HttpContext.Current.Request.Files;
  47:                  HttpPostedFile hpf = hfc[0];
  48:   
  49:                  return hpf.FileName;
  50:              }
  51:          }
  52:   
  53:          ////////////////////////////////////////////////////////////////////////////
  54:   
  55:          /// <summary>
  56:          ///
  57:          /// </summary>
  58:          public static bool File(string pathFile)
  59:          {
  60:              return File(pathFile, true);
  61:          }
  62:   
  63:          ////////////////////////////////////////////////////////////////////////////
  64:   
  65:          /// <summary>
  66:          ///
  67:          /// </summary>
  68:          public static bool File(string absoluteOrRelativePathFile, bool useTemporaryFolder)
  69:          {
  70:              bool b;
  71:              string absolutePath, directory;
  72:   
  73:              b = false;
  74:   
  75:              HttpFileCollection hfc = HttpContext.Current.Request.Files;
  76:              HttpPostedFile hpf = hfc[0];
  77:   
  78:              /*
  79:  
  80:  #if WFA
  81:                  absolute_path = AppDomain.CurrentDomain.BaseDirectory.ToString() + @"app_data\temp\";
  82:  #else
  83:                  if (hpf.ContentLength > 0)
  84:                  {
  85:                      if (System.Deployment.Application.ApplicationDeployment.IsNetworkDeployed) absolute_path = System.Deployment.Application.ApplicationDeployment.CurrentDeployment.DataDirectory + @"\";
  86:                      else absolute_path = AppDomain.CurrentDomain.BaseDirectory;
  87:  
  88:  
  89:                      hpf.SaveAs(absolute_path + relative_path_file);
  90:                      b = true;
  91:                  }
  92:  #endif
  93:               */
  94:   
  95:              try
  96:              {
  97:                  // this will detect the initial "C:\" in the path_file to decide if it is absolute or relative
  98:                  if (absoluteOrRelativePathFile.Contains(@":\"))
  99:                  {
 100:                      // absolute path file
 101:                      absolutePath = absoluteOrRelativePathFile;
 102:                  }
 103:                  else
 104:                  {
 105:                      absolutePath = global::Ia.Cl.Model.Default.AbsolutePath(useTemporaryFolder);
 106:   
 107:                      absolutePath += absoluteOrRelativePathFile;
 108:                  }
 109:   
 110:                  directory = absolutePath.Substring(0, absolutePath.LastIndexOf(@"\"));
 111:   
 112:                  if (!Directory.Exists(directory))
 113:                  {
 114:                      // create the directory it does not exist.
 115:                      Directory.CreateDirectory(directory);
 116:                  }
 117:   
 118:                  hpf.SaveAs(absolutePath);
 119:                  b = true;
 120:   
 121:                  /*
 122:                  using (FileStream fs = new FileStream(absolute_path, FileMode.Create))
 123:                  {
 124:                      using (StreamWriter sw = new StreamWriter(fs, Encoding.UTF8))
 125:                      {
 126:                          sw.WriteLine(line);
 127:                          b = true;
 128:                      }
 129:                  }
 130:                  */
 131:              }
 132:              catch (Exception)
 133:              {
 134:                  b = false;
 135:              }
 136:   
 137:              return b;
 138:          }
 139:   
 140:          ////////////////////////////////////////////////////////////////////////////
 141:   
 142:          /// <summary>
 143:          /// Read and file into a stream
 144:          /// </summary>
 145:          public static StreamReader Stream()
 146:          {
 147:              StreamReader sr;
 148:              HttpFileCollection hfc = HttpContext.Current.Request.Files;
 149:              HttpPostedFile hpf = hfc[0];
 150:   
 151:              sr = null;
 152:   
 153:              try
 154:              {
 155:                  sr = new StreamReader(hpf.InputStream);
 156:              }
 157:              catch (Exception)
 158:              {
 159:              }
 160:              finally
 161:              {
 162:              }
 163:   
 164:              return sr;
 165:          }
 166:   
 167:          ////////////////////////////////////////////////////////////////////////////
 168:   
 169:          /// <summary>
 170:          ///
 171:          /// </summary>
 172:          public static bool File(string path, int number)
 173:          {
 174:              return File(path, number, true);
 175:          }
 176:   
 177:          ////////////////////////////////////////////////////////////////////////////
 178:   
 179:          /// <summary>
 180:          ///
 181:          /// </summary>
 182:          public static bool File(string file, int number, bool tempFolder)
 183:          {
 184:              bool b;
 185:              int i, n, l;
 186:              string path, pathFile/*, ext*/;
 187:   
 188:              b = false;
 189:              n = 0;
 190:              //path = null;
 191:   
 192:              HttpFileCollection hfc = HttpContext.Current.Request.Files;
 193:   
 194:              for (i = 0; i < hfc.Count; i++)
 195:              {
 196:                  pathFile = "";
 197:   
 198:                  HttpPostedFile hpf = hfc[i];
 199:   
 200:                  l = hpf.FileName.LastIndexOf('.') + 1;
 201:   
 202:                  //ext = hpf.FileName.Substring(l, hpf.FileName.Length - l);
 203:   
 204:                  try
 205:                  {
 206:                      if (hpf.ContentLength > 0)
 207:                      {
 208:                          if (tempFolder)
 209:                          {
 210:                              path = global::Ia.Cl.Model.Default.AbsolutePath(tempFolder);
 211:   
 212:                              pathFile = path + file + "_" + number + "_" + n;// + "." + ext;
 213:                          }
 214:                          else
 215:                          {
 216:                              path = global::Ia.Cl.Model.Default.AbsolutePath();
 217:   
 218:                              pathFile = path + file + "_" + number + "_" + n;// +"." + ext;
 219:                          }
 220:   
 221:                          hpf.SaveAs(pathFile);
 222:                          b = true;
 223:                          n++;
 224:                      }
 225:                  }
 226:                  catch (Exception)
 227:                  {
 228:                      b = false;
 229:                  }
 230:              }
 231:   
 232:              return b;
 233:          }
 234:   
 235:          ////////////////////////////////////////////////////////////////////////////
 236:   
 237:          /// <summary>
 238:          ///
 239:          /// </summary>
 240:          public static void Media(string path, int number)
 241:          {
 242:              Media(path, number, true, false);
 243:          }
 244:   
 245:          ////////////////////////////////////////////////////////////////////////////
 246:   
 247:          /// <summary>
 248:          ///
 249:          /// </summary>
 250:          public static void Media(string relativePath, int num, bool tempFolder, bool overwrite)
 251:          {
 252:              int i, n;
 253:              string relativePathFile, r;
 254:   
 255:              n = 0;
 256:   
 257:              HttpFileCollection hfc = HttpContext.Current.Request.Files;
 258:   
 259:              for (i = 0; i < hfc.Count; i++)
 260:              {
 261:                  HttpPostedFile hpf = hfc[i];
 262:   
 263:                  try
 264:                  {
 265:                      if (hpf.ContentLength > 0)
 266:                      {
 267:                          // check if the path_file is an image
 268:                          if (hpf.ContentType == "image/jpeg" || hpf.ContentType == "image/pjpeg" || hpf.ContentType == "image/gif")
 269:                          {
 270:                              relativePathFile = relativePath + num + "_" + n + ".jpg";
 271:   
 272:                              if (!overwrite)
 273:                              {
 274:                                  while (global::Ia.Cl.Model.File.Exists(relativePathFile))
 275:                                  {
 276:                                      relativePathFile = relativePath + num + "_" + ++n + ".jpg";
 277:                                  }
 278:                              }
 279:   
 280:                              relativePathFile = relativePathFile.Replace(".jpg", "_temp.jpg");
 281:   
 282:                              // replace the steps below with a stream operation
 283:                              hpf.SaveAs(global::Ia.Cl.Model.Default.AbsolutePath() + relativePathFile);
 284:   
 285:                              global::Ia.Cl.Model.Image.CreateGeneralUse(relativePathFile, relativePath, num, n);
 286:   
 287:                              global::Ia.Cl.Model.File.Delete(relativePathFile);
 288:   
 289:                              n++;
 290:                          }
 291:                          else if (hpf.ContentType == "audio/x-pn-realaudio")
 292:                          {
 293:                          }
 294:                          else if (hpf.ContentType == "video/mp4")
 295:                          {
 296:                              relativePathFile = relativePath + num + "_" + n + ".mp4";
 297:   
 298:                              if (!overwrite)
 299:                              {
 300:                                  while (global::Ia.Cl.Model.File.Exists(relativePathFile))
 301:                                  {
 302:                                      relativePathFile = relativePath + num + "_" + ++n + ".mp4";
 303:                                  }
 304:                              }
 305:   
 306:                              // replace the steps below with a stream operation
 307:                              hpf.SaveAs(global::Ia.Cl.Model.Default.AbsolutePath() + relativePathFile);
 308:   
 309:                              n++;
 310:                          }
 311:                          else
 312:                          {
 313:                          }
 314:                      }
 315:                  }
 316:                  catch (Exception ex)
 317:                  {
 318:  #if DEBUG
 319:                      r = "Error: " + ex.ToString();
 320:  #else
 321:                      r = "Error: " + ex.Message;
 322:  #endif
 323:                  }
 324:                  finally
 325:                  {
 326:                  }
 327:              }
 328:          }
 329:   
 330:          ////////////////////////////////////////////////////////////////////////////
 331:          ////////////////////////////////////////////////////////////////////////////
 332:      }
 333:  }