public bool UploadFileData(FileData fileData)
        {
            bool result = false;
            try
            {
                string FilePath = Path.Combine(ConfigurationManager.AppSettings["PATH"], fileData.FileName);
                if (fileData.FilePosition == 0)
                {
                    CreateDirectoryIfNotExists(FilePath);
                    File.Create(FilePath).Close();
                }
                using (FileStream fileStream = new FileStream(FilePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
                {
                    fileStream.Seek(fileData.FilePosition, SeekOrigin.Begin);
                    fileStream.Write(fileData.BufferData, 0, fileData.BufferData.Length);
                }
            }
            catch (Exception ex)
            {
                ErrorDetails ed = new ErrorDetails();
                ed.ErrorCode = 1001;
                ed.ErrorMessage = ex.Message;
                throw new FaultException<ErrorDetails>(ed);
            }

            return result;
        }

        public string NewMediaObject(FileData mediaObject)
        {
            var mediaFile = new WorkflowMediaFile
            {
                FileName = mediaObject.name,
                Title = mediaObject.name,
                Culture = DataLocalizationFacade.DefaultLocalizationCulture.Name,
                Length = mediaObject.bits.Count(),
                MimeType = MimeTypeInfo.GetCanonical(mediaObject.type)
            };

            if (mediaFile.MimeType == MimeTypeInfo.Default)
            {
                mediaFile.MimeType = MimeTypeInfo.GetCanonicalFromExtension(Path.GetExtension(mediaFile.FileName));
            }

            using (Stream readStream = new MemoryStream(mediaObject.bits))
            {
                using (Stream writeStream = mediaFile.GetNewWriteStream())
                {
                    readStream.CopyTo(writeStream);
                }
            }
            string folderPath = string.Format("/Blog/{0}/{1:yyyy-MM-dd}", Author.Name, DateTime.Now);
            mediaFile.FolderPath = ForceGetMediaFolderPath(folderPath);
            var addedFile = DataFacade.AddNew<IMediaFile>(mediaFile);
            return MediaUrlHelper.GetUrl(addedFile);
        }

		public Block(StorageOptions storageOptions, ReadOptions readOptions, BlockHandle handle, FileData fileData)
		{
			try
			{
				_handle = handle;
				_storageOptions = storageOptions;
				_fileData = fileData;
				if (handle.Position > fileData.Size || (handle.Position + handle.Count + BlockTrailerSize) > fileData.Size)
					throw new CorruptedDataException("The specified accessor is beyond the bounds of the provided mappedFile");

				_accessor = _fileData.File.CreateAccessor(handle.Position, handle.Count + BlockTrailerSize);

				if (readOptions.VerifyChecksums)
				{
					var crc = Crc.Unmask(_accessor.ReadInt32(handle.Count + 1));
					var actualCrc = CalculateActualCrc(handle.Count + 1); // data + tag
					if (crc != actualCrc)
						throw new CorruptedDataException("block checksum mismatch");
				}
				RestartsCount = _accessor.ReadInt32(handle.Count - sizeof(int));
				RestartsOffset = handle.Count - (RestartsCount * sizeof(int)) - sizeof(int);
				if (RestartsOffset > handle.Count)
					throw new CorruptedDataException("restart offset wrapped around");
			}
			catch (Exception)
			{
				Dispose();
				throw;
			}
		}

        /// <summary>
        /// Copies the given file on "fromPath" to the "toPath". 
        /// </summary>
        /// <param name="fromPath">Relative path under configured application "resources" directory.
        /// A <see cref="System.String"/>
        /// </param>
        /// <param name="toPath">Relative path under configured application "documents" directory. See GetDirectoryRoot().
        /// A <see cref="System.String"/>
        /// </param>
        /// <returns>
        /// A <see cref="System.Boolean"/>
        /// </returns>
        public bool CopyFromResources(string fromPath, string toPath)
        {
            try {
                DirectoryData resourcesDir = GetDirectoryResources ();
                string fromFilePath = Path.Combine (resourcesDir.FullName, fromPath);
                FileData sourceFile = new FileData (fromFilePath);

                if (ExistsFile (sourceFile)) {
                    DirectoryData rootDir = GetDirectoryRoot ();
                    string toFilePath = Path.Combine (rootDir.FullName, toPath);

                    try {
                        File.Copy (fromFilePath, toFilePath);
                    } catch (Exception ex) {
                        SystemLogger.Log (SystemLogger.Module .CORE, "Error copying from file [" + fromFilePath + "] to file [" + toFilePath + "]", ex);
                        return false;
                    }
                    return true;
                } else {
                    SystemLogger.Log (SystemLogger.Module .CORE, "Error copying from file [" + fromFilePath + "]. File does not exists.");
                }
            } catch (Exception) {
                SystemLogger.Log (SystemLogger.Module .CORE, "Error copying from file [" + fromPath + "]. Unhandled exception.");
            }

            return false;
        }

 /// <summary>
 /// Constructor Parametrizado
 /// </summary>
 /// <param name="remoteNetUser">El usuario remoto con el cual se intercambiará el archivo</param>
 /// <param name="sendMessageDelegate">Un método con el cual se puedan envíar mensajes a la MANET</param>
 /// <param name="fileInformation">La información del archivo</param>
 /// <param name="FileData">Los parámetros de configuración</param>
 public FileMessageReceiver(NetUser remoteNetUser, SendMessageDelegate sendMessageDelegate, FileInformation fileInformation, FileData fileData)
     : base(remoteNetUser, sendMessageDelegate, fileInformation, fileData)
 {
     thisLock = new Object();
     this.Type = FileMessageHandlerType.DOWNLOAD;
     this.downloadDir = fileData.DownloadDir;
 }

        public void TestFileData()
        {
            AbstractFlight objFlight = null;
            IFileData handleFileData = new FileData();

            System.IO.StreamReader file =
              new System.IO.StreamReader(Directory.GetCurrentDirectory() + "\\input1.txt");

            objFlight = handleFileData.ProcessFile(file);

            Assert.AreEqual<double>(objFlight.TotAdjRev, 750);
            Assert.AreEqual<double>(objFlight.TotalCostOfFlight, 600);
            Assert.AreEqual<double>(objFlight.lstPassengers.Count, 6);
            Assert.AreEqual<decimal>(objFlight.FlightAircraft.NoOfSeats, 12);
            Assert.AreEqual<decimal>(objFlight.MinTakeOffLoadPercent, 75);

            file = new System.IO.StreamReader(Directory.GetCurrentDirectory() + "\\input.txt");

            objFlight = handleFileData.ProcessFile(file);

            Assert.AreEqual<double>(objFlight.TotAdjRev, 1010);
            Assert.AreEqual<double>(objFlight.TotalCostOfFlight, 800);
            Assert.AreEqual<double>(objFlight.lstPassengers.Count, 8);
            Assert.AreEqual<decimal>(objFlight.FlightAircraft.NoOfSeats, 8);
            Assert.AreEqual<decimal>(objFlight.MinTakeOffLoadPercent, 75);
        }

        public void TestDeleteFile()
        {
            FileData fd = new FileData("id", _fileName, _fileData);
            _fileQuery.Delete(fd);

            Assert.IsFalse(new FileInfo(Path.Combine(_workDirectory, _fileName)).Exists);
        }

        public FileImpl(FileData fileData)
        {
            m_fileData = fileData;
			m_fileList = new ObservableCollection<IContainer>();
            m_properties = new Dictionary<string, string>();
			this.WasReadOnly = fileData.WasReadOnly;
        }

 public void TestAddFile()
 {
     FileData fd = new FileData("id", _fileName, _fileData);
     _fileQuery.Insert(fd);
     FileInfo fi = new FileInfo(Path.Combine(_workDirectory,_fileName));
     Assert.IsTrue(fi.Exists);
 }

        public void TestDeleteFileNotExist()
        {
            string notExistingFileName = "somefilethatdoesnotexist.txt";
            FileData fd = new FileData("id", notExistingFileName, _fileData);
            _fileQuery.Delete(fd);

            Assert.IsFalse(new FileInfo(Path.Combine(_workDirectory, notExistingFileName)).Exists);
        }

 public override async Task<bool> DeleteFile(FileData file)
 {
     var path = GetFilePath(file);
     var fileToDelete = await GetStorageItem(path, false);
     if (fileToDelete == null) return false;
     await fileToDelete.DeleteAsync(StorageDeleteOption.PermanentDelete);
     return true;
 }

 /// <summary>
 /// Constructor parametrizado
 /// </summary>
 /// <param name="remoteNetUser">El usuario con quien se intercambia el archivo</param>
 /// <param name="remoteFileHandlerId">El id de la transferencia de archivo</param>
 /// <param name="sendMessageDelegate">Una función por la que se pueda enviar un mensaje</param>
 /// <param name="fileInformation">Información del archivo</param>
 /// <param name="fileData">Datos de configuración de archivos</param>
 public FileMessageSender(NetUser remoteNetUser, Guid remoteFileHandlerId, SendMessageDelegate sendMessageDelegate, FileInformation fileInformation, FileData fileData)
     : base(remoteNetUser, sendMessageDelegate, fileInformation, fileData)
 {
     FileName = fileInformation.Path;
     currentPart = 0;
     this.Type = FileMessageHandlerType.UPLOAD;
     this.Id = remoteFileHandlerId;
 }

        public static ResourceFile UploadResourceFile(FileData files, int resourceId)
        {
            ResourceFile resFileRet = new ResourceFile();
            //we get the information
            using (ResourcesDataContext dc = new ResourcesDataContext())
            {
                //check if we have the file type
                int typeid = 0;
                var type = (from d in dc.bhdFileTypes
                            where d.contentType == files.fileType
                            && d.isActive
                            select d).FirstOrDefault();
                if (type == null)
                {
                    bhdFileType ft = new bhdFileType();
                    ft.contentType = files.fileType;
                    string extension = files.fileName;
                    int pos = extension.LastIndexOf('.');
                    ft.extension = extension.Substring(pos + 1, extension.Length - (pos + 1));
                    ft.isActive = true;
                    dc.bhdFileTypes.InsertOnSubmit(ft);
                    dc.SubmitChanges();
                    typeid = ft.id;
                }
                else
                {
                    typeid = type.id;
                }

                bhdFile f = new bhdFile();
                f.size = files.fileSize;
                f.name = files.fileName;
                f.isActive = true;
                f.fileTypeId = typeid;
                dc.bhdFiles.InsertOnSubmit(f);
                dc.SubmitChanges();

                bhdFileData fd = new bhdFileData();
                fd.fileId = f.id;
                fd.data = files.fileData;
                dc.bhdFileDatas.InsertOnSubmit(fd);
                dc.SubmitChanges();


                bhdResourceFile rf = new bhdResourceFile();
                rf.resourceId = resourceId;
                rf.fileId = f.id;
                dc.bhdResourceFiles.InsertOnSubmit(rf);
                dc.SubmitChanges();

                ResourceFile tmpFileRes = new ResourceFile();
                tmpFileRes.fileid = rf.fileId;
                tmpFileRes.filename = f.name;
                resFileRet = tmpFileRes;
                
            }
            return resFileRet;
        }

        public void OpenItem(FileData data)
        {
            if (this.IsUpdating || data?.FullPath == null)
            {
                return;
            }

            Factory.Resolve<OpenFileCommand>().Execute(data.FullPath);
        }

 public void AddFile(string fileName)
 {
   FileInfo fileInfo = new FileInfo(fileName);
   FileData fileData = new FileData(fileInfo);
   if (testCaseFiles == null)
     testCaseFiles = new SortedSetAny<FileData>();
   testCaseFiles.Add(fileData);
   fileData.SetFileBytes();
 }

        static void Main(string[] args)
        {
            string filename = args[0];
            int files = 5;
            int subpacks = 2;

            PackFile packData = new PackFile();

            using(FileStream s = File.Open(filename, FileMode.Open, FileAccess.Read))
            using(BinaryReader reader = new BEBinaryReader(s))
            {
                while(true)
                {
                    packData.header = reader.ReadInt32();
                    if (packData.header == 0) break;
                    packData.filesInPack = reader.ReadInt32();
                    //packData.header.i3 = reader.ReadInt32();

                    Console.WriteLine("Pack Header");
                    Console.WriteLine("First Int: " + (uint)packData.header);
                    Console.WriteLine("Second Int: " + (uint)packData.filesInPack);
                    files = packData.filesInPack;

                    for (int i = 0; i < files; i++)
                    {
                        Console.WriteLine("File " + i);
                        string readName = reader.ReadString();
                        packData.filenames.Add(readName);

                        Console.WriteLine("Name: " + packData.filenames[i]);

                        FileData fileDat = new FileData();
                        fileDat.offset = reader.ReadInt32();
                        fileDat.size = reader.ReadInt32();
                        fileDat.i3 = reader.ReadInt32();
                        packData.fileData.Add(fileDat);

                        Console.WriteLine("Data: ( " + packData.fileData[i].offset + " , " + packData.fileData[i].size + ", " + (uint)packData.fileData[i].i3 + " )");
                    }

                    s.Seek(packData.header, SeekOrigin.Begin);
                }

                for (int i = 0; i < packData.fileData.Count; i++)
                {
                    using (FileStream outfile = File.Open(packData.filenames[i], FileMode.Create, FileAccess.Write))
                    {
                        s.Seek(packData.fileData[i].offset, SeekOrigin.Begin);
                        byte[] file = reader.ReadBytes(packData.fileData[i].size);
                        outfile.Write(file, 0, file.Length);
                    }

                }

            }
        }

        public void IsNotNull_WhenValueIsNull_WritesTraceMessage()
        {
            var listener = new TestListener();
            Trace.Listeners.Add(listener);

            var data = new FileData { StringValue = null };
            Assert.Throws<ArgumentException>(() => data.IsNotNull());

            Assert.AreEqual("Test:IsNotNullFailed:IsNotNull", listener.Output);
            Trace.Listeners.Remove(listener);
        }

        public void DoesNotContainANumber_WhenStringDoesContainANumber_WritesTraceMessage()
        {
            var listener = new TestListener();
            Trace.Listeners.Add(listener);

            var data = new FileData { StringValue = "1" };
            Assert.Throws<ArgumentException>(() => data.DoesNotContainANumber());

            Assert.AreEqual("Test:DoesNotContainANumberFailed:DoesNotContainANumber", listener.Output);
            Trace.Listeners.Remove(listener);
        }

 public void setMetatdata(FileData f, string metadata)
 {
     foreach (ContentManager.EntryElement ee in e.CurrentRoot.Children)
     {
         if (f.FileName.Equals(ee.File.FileName))
         {
             e.addMetadata(ee.File, metadata);
             break;
         }
     }
 }

	    public void WriteFile(string virtualPath, System.IO.Stream inputStream, DateTime? lastWriteTime = null)
		{
			var temp = new byte[10000];
			long size = inputStream.Read(temp, 0, temp.Length);

			var buffer = new byte[size];
			Array.Copy(temp, buffer, size);

			contents[virtualPath] = buffer;
			files[virtualPath] = new FileData { VirtualPath = virtualPath, Updated = lastWriteTime ?? DateTime.UtcNow};
		}