/// <summary> /// Sends the file. /// </summary> /// <param name="context">The context.</param> /// <param name="file">The file.</param> private static void SendFile(HttpContext context, Rock.Model.BinaryFile file) { context.Response.ContentType = file.MimeType; context.Response.AddHeader("content-disposition", "inline;filename=" + file.FileName); context.Response.BinaryWrite(file.Data); context.Response.Flush(); }
/// <summary> /// Resizes the specified context. /// </summary> /// <param name="context">The context.</param> /// <param name="file">The file.</param> private static void Resize(HttpContext context, Rock.Model.BinaryFile file) { ResizeSettings settings = new ResizeSettings(context.Request.QueryString); MemoryStream resizedStream = new MemoryStream(); ImageBuilder.Current.Build(new MemoryStream(file.Data), resizedStream, settings); file.Data = resizedStream.GetBuffer(); }
/// <summary> /// Caches the specified file. /// </summary> /// <param name="file">The file.</param> /// <param name="physFilePath">The phys file path.</param> private static void Cache(Rock.Model.BinaryFile file, string physFilePath) { try { using (BinaryWriter binWriter = new BinaryWriter(System.IO.File.Open(physFilePath, FileMode.Create))) { binWriter.Write(file.Data); } } catch { /* do nothing, not critical if this fails, although TODO: log */ } }
/// <summary> /// Copies the properties from another BinaryFile object to this BinaryFile object /// </summary> /// <param name="target">The target.</param> /// <param name="source">The source.</param> public static void CopyPropertiesFrom(this BinaryFile target, BinaryFile source) { target.Id = source.Id; target.BinaryFileTypeId = source.BinaryFileTypeId; target.ContentLastModified = source.ContentLastModified; target.Description = source.Description; target.FileName = source.FileName; target.ForeignGuid = source.ForeignGuid; target.ForeignKey = source.ForeignKey; target.IsSystem = source.IsSystem; target.IsTemporary = source.IsTemporary; target.MimeType = source.MimeType; target.Path = source.Path; target.StorageEntitySettings = source.StorageEntitySettings; target.CreatedDateTime = source.CreatedDateTime; target.ModifiedDateTime = source.ModifiedDateTime; target.CreatedByPersonAliasId = source.CreatedByPersonAliasId; target.ModifiedByPersonAliasId = source.ModifiedByPersonAliasId; target.Guid = source.Guid; target.ForeignId = source.ForeignId; }
/// <summary> /// Saves the specified <see cref="Rock.Model.BinaryFile"/>. /// </summary> /// <param name="item">A <see cref="Rock.Model.BinaryFile"/> to save.</param> /// <param name="personId">A <see cref="System.Int32"/> representing the PersonId of the <see cref="Rock.Model.Person"/> who is saving the BinaryFile..</param> /// <returns></returns> public override bool Save(BinaryFile item, int?personId) { item.LastModifiedDateTime = DateTime.Now; Rock.Storage.ProviderComponent storageProvider = DetermineBinaryFileStorageProvider(item); if (storageProvider != null) { //// if this file is getting replaced, and we can determine the StorageProvider, use the provider to get and remove the file from the provider's //// external storage medium before we save it again. This especially important in cases where the provider for this filetype has changed //// since it was last saved // first get the FileContent from the old/current fileprovider in case we need to save it somewhere else item.Data = item.Data ?? new BinaryFileData(); item.Data.Content = storageProvider.GetFileContent(item, HttpContext.Current); // now, remove it from the old/current fileprovider storageProvider.RemoveFile(item, HttpContext.Current); } // when a file is saved (unless it is getting Deleted/Saved), it should use the StoredEntityType that is associated with the BinaryFileType if (item.BinaryFileType != null) { // make sure that it updated to use the same storage as specified by the BinaryFileType if (item.StorageEntityTypeId != item.BinaryFileType.StorageEntityTypeId) { item.SetStorageEntityTypeId(item.BinaryFileType.StorageEntityTypeId); storageProvider = DetermineBinaryFileStorageProvider(item); } } if (storageProvider != null) { // save the file to the provider's new storage medium storageProvider.SaveFile(item, HttpContext.Current); } return(base.Save(item, personId)); }
/// <summary> /// Instantiates a new DTO object from the entity /// </summary> /// <param name="binaryFile"></param> public BinaryFileDto(BinaryFile binaryFile) { CopyFromModel(binaryFile); }
/// <summary> /// To the dto. /// </summary> /// <param name="value">The value.</param> /// <returns></returns> public static BinaryFileDto ToDto(this BinaryFile value) { return(new BinaryFileDto(value)); }
/// <summary> /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler" /> interface. /// </summary> /// <param name="context">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param> public void ProcessRequest(HttpContext context) { context.Response.Clear(); if (context.Request.QueryString == null || context.Request.QueryString.Count == 0) { context.Response.StatusCode = 404; context.Response.End(); return; } string anID = context.Request.QueryString[0]; int id; if (!int.TryParse(anID, out id)) { context.Response.StatusCode = 404; context.Response.End(); return; } try { BinaryFileService fileService = new BinaryFileService(); Rock.Model.BinaryFile file = null; string cacheName = Uri.EscapeDataString(context.Request.Url.Query); string physFilePath = context.Request.MapPath(string.Format("~/Cache/{0}", cacheName)); // Is it cached if (System.IO.File.Exists(physFilePath)) { // When was file last modified dynamic fileInfo = fileService .Queryable() .Where(f => f.Id == id) .Select(f => new { MimeType = f.MimeType, LastModifiedTime = f.LastModifiedTime }) .FirstOrDefault(); file = new Rock.Model.BinaryFile(); file.MimeType = fileInfo.MimeType; file.LastModifiedTime = fileInfo.LastModifiedTime; // Is cached version newer? if (file.LastModifiedTime.HasValue && file.LastModifiedTime.Value.CompareTo(System.IO.File.GetCreationTime(physFilePath)) <= 0) { file.Data = FetchFromCache(physFilePath); } } if (file == null || file.Data == null) { file = fileService.Get(id); if (file != null) { if (WantsImageResizing(context)) { Resize(context, file); } Cache(file, physFilePath); } } if (file == null || file.Data == null) { context.Response.StatusCode = 404; context.Response.End(); return; } // Post process SendFile(context, file); } catch { } }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="requestDocumentType">The benevolence request document file type.</param> public int Map(ZipArchive folder, BinaryFileType requestDocumentType) { var lookupContext = new RockContext(); var emptyJsonObject = "{}"; var newFileList = new Dictionary <KeyValuePair <int, int>, Rock.Model.BinaryFile>(); var benevolenceRequestService = new BenevolenceRequestService(lookupContext); var importedRequests = benevolenceRequestService .Queryable().AsNoTracking().Where(t => t.ForeignId != null) .ToDictionary(t => ( int )t.ForeignId, t => t.Id); var importedRequestDocuments = new BenevolenceRequestDocumentService(lookupContext) .Queryable().AsNoTracking().Where(t => t.ForeignId != null) .ToDictionary(t => ( int )t.ForeignId, t => t.Id); var storageProvider = requestDocumentType.StorageEntityTypeId == DatabaseProvider.EntityType.Id ? ( ProviderComponent )DatabaseProvider : ( ProviderComponent )FileSystemProvider; var completedItems = 0; var totalEntries = folder.Entries.Count; var percentage = (totalEntries - 1) / 100 + 1; ReportProgress(0, string.Format("Verifying benevolence request documents import ({0:N0} found.", totalEntries)); foreach (var file in folder.Entries) { var fileExtension = Path.GetExtension(file.Name); if (FileTypeBlackList.Contains(fileExtension)) { LogException("Binary File Import", string.Format("{0} filetype not allowed ({1})", fileExtension, file.Name)); continue; } var nameWithoutExtension = file.Name.ReplaceLastOccurrence(fileExtension, string.Empty); var parsedFileName = nameWithoutExtension.Split('_').ToList(); // // Benevolence Request docs should follow this pattern: // 0. Request ForeignId // 1. FileName // 2. Doc Id var foreignBenevolenceRequestId = parsedFileName[0].AsType <int?>(); // Make sure the Benevolence Request exists if (foreignBenevolenceRequestId != null && importedRequests.ContainsKey(( int )foreignBenevolenceRequestId)) { var benevolenceRequest = benevolenceRequestService.Queryable().AsNoTracking().FirstOrDefault(r => r.ForeignId.HasValue && r.ForeignId == foreignBenevolenceRequestId); var documentForeignId = -1; var fileName = string.Empty; if (parsedFileName.Count() >= 3) { documentForeignId = parsedFileName.LastOrDefault().AsInteger(); // If document foreignId is provided, make sure it doesn't already exist if (documentForeignId > 0 && importedRequestDocuments.ContainsKey(documentForeignId)) { continue; } // Extract filename parsedFileName.RemoveAt(parsedFileName.Count() - 1); // Remove Doc Id from end parsedFileName.RemoveAt(0); // Remove Request ForeignId from beginning fileName = string.Join("_", parsedFileName); } else { var filename = file.Name.ReplaceLastOccurrence(fileExtension, string.Empty); } // Create the binary file var rockFile = new Rock.Model.BinaryFile { IsSystem = false, IsTemporary = false, MimeType = GetMIMEType(file.Name), BinaryFileTypeId = requestDocumentType.Id, FileName = fileName, CreatedDateTime = file.LastWriteTime.DateTime, ModifiedDateTime = file.LastWriteTime.DateTime, CreatedByPersonAliasId = ImportPersonAliasId }; rockFile.SetStorageEntityTypeId(requestDocumentType.StorageEntityTypeId); rockFile.StorageEntitySettings = emptyJsonObject; if (requestDocumentType.AttributeValues.Any()) { rockFile.StorageEntitySettings = requestDocumentType.AttributeValues .ToDictionary(a => a.Key, v => v.Value.Value).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using (var fileContent = new StreamReader(file.Open())) { rockFile.ContentStream = new MemoryStream(fileContent.BaseStream.ReadBytesToEnd()); } // add this document file to the Rock transaction newFileList.Add(new KeyValuePair <int, int>(importedRequests[( int )foreignBenevolenceRequestId], documentForeignId), rockFile); completedItems++; if (completedItems % percentage < 1) { var percentComplete = completedItems / percentage; ReportProgress(percentComplete, string.Format("{0:N0} benevolence document files imported ({1}% complete).", completedItems, percentComplete)); } if (completedItems % ReportingNumber < 1) { SaveFiles(newFileList, storageProvider); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if (newFileList.Any()) { SaveFiles(newFileList, storageProvider); } ReportProgress(100, string.Format("Finished document import: {0:N0} benevolence documents imported.", completedItems)); return(completedItems); }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="ministryFileType">Type of the ministry file.</param> /// <param name="storageProvider">The storage provider.</param> public void Map( ZipArchive folder, BinaryFileType ministryFileType, ProviderComponent storageProvider ) { var lookupContext = new RockContext(); var personEntityTypeId = EntityTypeCache.GetId<Person>(); var fileFieldTypeId = FieldTypeCache.Read( Rock.SystemGuid.FieldType.FILE.AsGuid(), lookupContext ).Id; var existingAttributes = new AttributeService( lookupContext ).GetByFieldTypeId( fileFieldTypeId ) .Where( a => a.EntityTypeId == personEntityTypeId ) .ToDictionary( a => a.Key, a => a.Id ); var emptyJsonObject = "{}"; var newFileList = new List<DocumentKeys>(); int completed = 0; int totalRows = folder.Entries.Count; int percentage = ( totalRows - 1 ) / 100 + 1; ReportProgress( 0, string.Format( "Verifying files import ({0:N0} found.", totalRows ) ); foreach ( var file in folder.Entries ) { var fileExtension = Path.GetExtension( file.Name ); var fileMimeType = Extensions.GetMIMEType( file.Name ); if ( BinaryFileComponent.FileTypeBlackList.Contains( fileExtension ) ) { LogException( "Binary File Import", string.Format( "{0} filetype not allowed ({1})", fileExtension, file.Name ) ); continue; } else if ( fileMimeType == null ) { LogException( "Binary File Import", string.Format( "{0} filetype not recognized ({1})", fileExtension, file.Name ) ); continue; } string[] parsedFileName = file.Name.Split( '_' ); // Ministry docs should follow this pattern: // 0. Firstname // 1. Lastname // 2. ForeignId // 3. Filename var personForeignId = parsedFileName[2].AsType<int?>(); var personKeys = BinaryFileComponent.ImportedPeople.FirstOrDefault( p => p.IndividualId == personForeignId ); if ( personKeys != null ) { var rockFile = new Rock.Model.BinaryFile(); rockFile.IsSystem = false; rockFile.IsTemporary = false; rockFile.FileName = file.Name; rockFile.MimeType = fileMimeType; rockFile.BinaryFileTypeId = ministryFileType.Id; rockFile.CreatedDateTime = file.LastWriteTime.DateTime; rockFile.ModifiedDateTime = ImportDateTime; rockFile.Description = string.Format( "Imported as {0}", file.Name ); rockFile.SetStorageEntityTypeId( ministryFileType.StorageEntityTypeId ); rockFile.StorageEntitySettings = emptyJsonObject; if ( ministryFileType.AttributeValues.Any() ) { rockFile.StorageEntitySettings = ministryFileType.AttributeValues .ToDictionary( a => a.Key, v => v.Value.Value ).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using ( var fileContent = new StreamReader( file.Open() ) ) { rockFile.ContentStream = new MemoryStream( fileContent.BaseStream.ReadBytesToEnd() ); } var attributePattern = "[A-Za-z0-9-]+"; var attributeName = Regex.Match( parsedFileName[3].RemoveWhitespace(), attributePattern ); var attributeKey = attributeName.Value.RemoveWhitespace(); // change key to default key for Background Check Documents if ( attributeKey == "BackgroundCheck" ) { attributeKey = "BackgroundCheckDocument"; } if ( !existingAttributes.ContainsKey( attributeKey ) ) { var newAttribute = new Attribute(); newAttribute.FieldTypeId = fileFieldTypeId; newAttribute.EntityTypeId = personEntityTypeId; newAttribute.EntityTypeQualifierColumn = string.Empty; newAttribute.EntityTypeQualifierValue = string.Empty; newAttribute.Key = attributeKey; newAttribute.Name = attributeName.Value; newAttribute.Description = attributeName.Value + " created by binary file import"; newAttribute.CreatedDateTime = ImportDateTime; newAttribute.ModifiedDateTime = ImportDateTime; newAttribute.IsGridColumn = false; newAttribute.IsMultiValue = false; newAttribute.IsRequired = false; newAttribute.AllowSearch = false; newAttribute.IsSystem = false; newAttribute.Order = 0; newAttribute.AttributeQualifiers.Add( new AttributeQualifier() { Key = "binaryFileType", Value = ministryFileType.Guid.ToString() } ); lookupContext.Attributes.Add( newAttribute ); lookupContext.SaveChanges(); existingAttributes.Add( newAttribute.Key, newAttribute.Id ); } newFileList.Add( new DocumentKeys() { PersonId = personKeys.PersonId, AttributeId = existingAttributes[attributeKey], File = rockFile } ); completed++; if ( completed % percentage < 1 ) { int percentComplete = completed / percentage; ReportProgress( percentComplete, string.Format( "{0:N0} files imported ({1}% complete).", completed, percentComplete ) ); } else if ( completed % ReportingNumber < 1 ) { SaveFiles( newFileList, storageProvider ); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if ( newFileList.Any() ) { SaveFiles( newFileList, storageProvider ); } ReportProgress( 100, string.Format( "Finished files import: {0:N0} addresses imported.", completed ) ); }
/// <summary> /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler" /> interface. /// </summary> /// <param name="context">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param> /// <exception cref="WebFaultException">Must be logged in</exception> public void ProcessRequest(HttpContext context) { // ********************************************* // TODO: verify user is authorized to save file! // ********************************************* if (!context.User.Identity.IsAuthenticated) { throw new WebFaultException <string>("Must be logged in", System.Net.HttpStatusCode.Forbidden); } try { HttpPostedFile uploadedFile = null; HttpFileCollection hfc = context.Request.Files; foreach (string fk in hfc.AllKeys) { uploadedFile = hfc[fk]; break; } // No file or no data? No good. if (uploadedFile == null || uploadedFile.ContentLength == 0) { context.Response.Write("0"); return; } BinaryFileService fileService = new BinaryFileService(); Rock.Model.BinaryFile cmsFile = null; // was an ID given? if so, fetch that file and replace it with the new one if (context.Request.QueryString.Count > 0) { string anID = context.Request.QueryString[0]; int id; cmsFile = (int.TryParse(anID, out id)) ? fileService.Get(id) : fileService.GetByEncryptedKey(anID); } if (cmsFile == null) { // ...otherwise create a new Cms File cmsFile = new Rock.Model.BinaryFile(); cmsFile.IsTemporary = true; fileService.Add(cmsFile, null); } cmsFile.MimeType = uploadedFile.ContentType; cmsFile.FileName = Path.GetFileName(uploadedFile.FileName); SaveData(context, uploadedFile.InputStream, cmsFile); fileService.Save(cmsFile, null); cmsFile.Data = null; context.Response.Write(new { Id = cmsFile.Id, FileName = cmsFile.FileName }.ToJson()); } catch (Exception ex) { context.Response.Write("err:" + ex.Message + "<br>" + ex.StackTrace); } }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="personImageType">Type of the person image file.</param> public void Map(ZipArchive folder, BinaryFileType personImageType) { // check for existing images var lookupContext = new RockContext(); var existingImageList = new PersonService(lookupContext).Queryable().AsNoTracking() .Where(p => p.Photo != null) .ToDictionary(p => p.Id, p => p.Photo.CreatedDateTime); var emptyJsonObject = "{}"; var newFileList = new Dictionary <int, Rock.Model.BinaryFile>(); var storageProvider = personImageType.StorageEntityTypeId == DatabaseProvider.EntityType.Id ? (ProviderComponent)DatabaseProvider : (ProviderComponent)FileSystemProvider; var completedItems = 0; var totalEntries = folder.Entries.Count; var percentage = (totalEntries - 1) / 100 + 1; ReportProgress(0, string.Format("Verifying person images import ({0:N0} found.", totalEntries)); foreach (var file in folder.Entries) { var fileExtension = Path.GetExtension(file.Name); if (FileTypeBlackList.Contains(fileExtension)) { LogException("Binary File Import", string.Format("{0} filetype not allowed ({1})", fileExtension, file.Name)); continue; } var personForeignId = Path.GetFileNameWithoutExtension(file.Name).AsType <int?>(); var personKeys = ImportedPeople.FirstOrDefault(p => p.PersonForeignId == personForeignId); if (personKeys != null) { // only import the most recent profile photo if (!existingImageList.ContainsKey(personKeys.PersonId) || existingImageList[personKeys.PersonId].Value < file.LastWriteTime.DateTime) { var rockFile = new Rock.Model.BinaryFile { IsSystem = false, IsTemporary = false, FileName = file.Name, BinaryFileTypeId = personImageType.Id, MimeType = GetMIMEType(file.Name), CreatedDateTime = file.LastWriteTime.DateTime, Description = string.Format("Imported as {0}", file.Name) }; rockFile.SetStorageEntityTypeId(personImageType.StorageEntityTypeId); rockFile.StorageEntitySettings = emptyJsonObject; if (personImageType.AttributeValues.Any()) { rockFile.StorageEntitySettings = personImageType.AttributeValues .ToDictionary(a => a.Key, v => v.Value.Value).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using (var fileContent = new StreamReader(file.Open())) { rockFile.ContentStream = new MemoryStream(fileContent.BaseStream.ReadBytesToEnd()); } newFileList.Add(personKeys.PersonId, rockFile); } completedItems++; if (completedItems % percentage < 1) { var percentComplete = completedItems / percentage; ReportProgress(percentComplete, string.Format("{0:N0} person image files imported ({1}% complete).", completedItems, percentComplete)); } else if (completedItems % ReportingNumber < 1) { SaveFiles(newFileList, storageProvider); // add image keys to master list foreach (var newFile in newFileList) { existingImageList.AddOrReplace(newFile.Key, newFile.Value.CreatedDateTime); } // Reset batch list newFileList.Clear(); ReportPartialProgress(); } } } if (newFileList.Any()) { SaveFiles(newFileList, storageProvider); } lookupContext.Dispose(); ReportProgress(100, string.Format("Finished files import: {0:N0} person images imported.", completedItems)); }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="ministryFileType">Type of the ministry file.</param> public int Map(ZipArchive folder, BinaryFileType ministryFileType) { var lookupContext = new RockContext(); var personEntityTypeId = EntityTypeCache.GetId <Person>(); var binaryFileTypeService = new BinaryFileTypeService(lookupContext); var fileFieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.FILE.AsGuid(), lookupContext).Id; var backgroundFieldTypeId = FieldTypeCache.Get(Rock.SystemGuid.FieldType.BACKGROUNDCHECK.AsGuid(), lookupContext).Id; var existingAttributes = new AttributeService(lookupContext).GetByFieldTypeId(fileFieldTypeId) .Where(a => a.EntityTypeId == personEntityTypeId) .ToDictionary(a => a.Key, a => a); var backgroundCheckFileAttributes = new AttributeService(lookupContext).GetByFieldTypeId(backgroundFieldTypeId) .Where(a => a.EntityTypeId == personEntityTypeId) .ToDictionary(a => a.Key, a => a); foreach (var backgroundCheckFileAttribute in backgroundCheckFileAttributes) { if (!existingAttributes.ContainsKey(backgroundCheckFileAttribute.Key)) { existingAttributes.Add(backgroundCheckFileAttribute.Key, backgroundCheckFileAttribute.Value); } } var emptyJsonObject = "{}"; var newFileList = new List <DocumentKeys>(); var completedItems = 0; var totalRows = folder.Entries.Count; var percentage = (totalRows - 1) / 100 + 1; ReportProgress(0, string.Format("Verifying ministry document import ({0:N0} found)", totalRows)); foreach (var file in folder.Entries.OrderBy(f => f.Name)) { var fileExtension = Path.GetExtension(file.Name); if (FileTypeBlackList.Contains(fileExtension)) { LogException("Binary File Import", string.Format("{0} filetype not allowed ({1})", fileExtension, file.Name)); continue; } var nameWithoutExtension = file.Name.ReplaceLastOccurrence(fileExtension, string.Empty); var parsedFileName = nameWithoutExtension.Split('_'); // Ministry docs should follow this pattern: // 0. Firstname // 1. Lastname // 2. ForeignId // 3. Filename // 4. Doc Id if (parsedFileName.Length < 3) { break; } var personForeignId = parsedFileName[2].AsType <int?>(); var personKeys = ImportedPeople.FirstOrDefault(p => p.PersonForeignId == personForeignId); if (personKeys != null) { var attributeName = string.Empty; var documentForeignId = string.Empty; if (parsedFileName.Count() > 4) { attributeName = parsedFileName[3]; documentForeignId = parsedFileName[4]; } else { var filename = parsedFileName[3].ReplaceLastOccurrence(fileExtension, string.Empty); attributeName = Regex.Replace(filename, "\\d{4,}[.\\w]+$", string.Empty); documentForeignId = Regex.Match(filename, "\\d+$").Value; } // append "Document" to attribute name to create unique attributes // this matches core attribute "Background Check Document" attributeName = !attributeName.EndsWith("Document", StringComparison.OrdinalIgnoreCase) ? string.Format("{0} Document", attributeName) : attributeName; var attributeKey = attributeName.RemoveSpecialCharacters(); Attribute fileAttribute = null; var attributeBinaryFileType = ministryFileType; if (!existingAttributes.ContainsKey(attributeKey)) { fileAttribute = new Attribute { FieldTypeId = fileFieldTypeId, EntityTypeId = personEntityTypeId, EntityTypeQualifierColumn = string.Empty, EntityTypeQualifierValue = string.Empty, Key = attributeKey, Name = attributeName, Description = string.Format("{0} created by binary file import", attributeName), IsGridColumn = false, IsMultiValue = false, IsRequired = false, AllowSearch = false, IsSystem = false, Order = 0 }; fileAttribute.AttributeQualifiers.Add(new AttributeQualifier() { Key = "binaryFileType", Value = ministryFileType.Guid.ToString() }); lookupContext.Attributes.Add(fileAttribute); lookupContext.SaveChanges(); existingAttributes.Add(fileAttribute.Key, fileAttribute); } else { // if attribute already exists in Rock, override default file type with the Rock-specified file type fileAttribute = existingAttributes[attributeKey]; var attributeBinaryFileTypeGuid = fileAttribute.AttributeQualifiers.FirstOrDefault(q => q.Key.Equals("binaryFileType")); if (attributeBinaryFileTypeGuid != null) { attributeBinaryFileType = binaryFileTypeService.Get(attributeBinaryFileTypeGuid.Value.AsGuid()); } } var rockFile = new Rock.Model.BinaryFile { IsSystem = false, IsTemporary = false, MimeType = GetMIMEType(file.Name), BinaryFileTypeId = attributeBinaryFileType.Id, FileName = file.Name, Description = string.Format("Imported as {0}", file.Name), CreatedDateTime = file.LastWriteTime.DateTime, ModifiedDateTime = file.LastWriteTime.DateTime, CreatedByPersonAliasId = ImportPersonAliasId, ForeignKey = documentForeignId, ForeignId = documentForeignId.AsIntegerOrNull() }; rockFile.SetStorageEntityTypeId(attributeBinaryFileType.StorageEntityTypeId); rockFile.StorageEntitySettings = emptyJsonObject; if (attributeBinaryFileType.AttributeValues != null) { rockFile.StorageEntitySettings = attributeBinaryFileType.AttributeValues .ToDictionary(a => a.Key, v => v.Value.Value).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using (var fileContent = new StreamReader(file.Open())) { rockFile.ContentStream = new MemoryStream(fileContent.BaseStream.ReadBytesToEnd()); } newFileList.Add(new DocumentKeys() { PersonId = personKeys.PersonId, AttributeId = fileAttribute.Id, File = rockFile }); completedItems++; if (completedItems % percentage < 1) { var percentComplete = completedItems / percentage; ReportProgress(percentComplete, string.Format("{0:N0} ministry document files imported ({1}% complete).", completedItems, percentComplete)); } if (completedItems % ReportingNumber < 1) { SaveFiles(newFileList); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if (newFileList.Any()) { SaveFiles(newFileList); } ReportProgress(100, string.Format("Finished documents import: {0:N0} ministry documents imported.", completedItems)); return(completedItems); }
/// <summary> /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler" /> interface. /// </summary> /// <param name="context">An <see cref="T:System.Web.HttpContext" /> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param> public void ProcessRequest( HttpContext context ) { context.Response.Clear(); if ( context.Request.QueryString == null || context.Request.QueryString.Count == 0) { context.Response.StatusCode = 404; context.Response.End(); return; } string anID = context.Request.QueryString[0]; int id; if (!int.TryParse( anID, out id)) { context.Response.StatusCode = 404; context.Response.End(); return; } try { BinaryFileService fileService = new BinaryFileService(); Rock.Model.BinaryFile file = null; string cacheName = Uri.EscapeDataString( context.Request.Url.Query ); string physFilePath = context.Request.MapPath( string.Format( "~/Cache/{0}", cacheName ) ); // Is it cached if ( System.IO.File.Exists( physFilePath ) ) { // When was file last modified dynamic fileInfo = fileService .Queryable() .Where( f => f.Id == id ) .Select( f => new { MimeType = f.MimeType, LastModifiedTime = f.LastModifiedTime } ) .FirstOrDefault(); file = new Rock.Model.BinaryFile(); file.MimeType = fileInfo.MimeType; file.LastModifiedTime = fileInfo.LastModifiedTime; // Is cached version newer? if ( file.LastModifiedTime.HasValue && file.LastModifiedTime.Value.CompareTo( System.IO.File.GetCreationTime( physFilePath ) ) <= 0 ) file.Data = FetchFromCache( physFilePath ); } if ( file == null || file.Data == null ) { file = fileService.Get( id ); if ( file != null ) { if ( WantsImageResizing( context ) ) Resize( context, file ); Cache( file, physFilePath ); } } if ( file == null || file.Data == null ) { context.Response.StatusCode = 404; context.Response.End(); return; } // Post process SendFile( context, file ); } catch { } }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="transactionImageType">Type of the transaction image file.</param> public void Map(ZipArchive folder, BinaryFileType transactionImageType) { var lookupContext = new RockContext(); var emptyJsonObject = "{}"; var newFileList = new Dictionary <int, Rock.Model.BinaryFile>(); var transactionIdList = new FinancialTransactionService(lookupContext) .Queryable().AsNoTracking().Where(t => t.ForeignId != null) .ToDictionary(t => (int)t.ForeignId, t => t.Id); var storageProvider = transactionImageType.StorageEntityTypeId == DatabaseProvider.EntityType.Id ? (ProviderComponent)DatabaseProvider : (ProviderComponent)FileSystemProvider; int completed = 0; int totalRows = folder.Entries.Count; int percentage = (totalRows - 1) / 100 + 1; ReportProgress(0, string.Format("Verifying files import ({0:N0} found.", totalRows)); foreach (var file in folder.Entries) { var fileExtension = Path.GetExtension(file.Name); if (BinaryFileComponent.FileTypeBlackList.Contains(fileExtension)) { LogException("Binary File Import", string.Format("{0} filetype not allowed ({1})", fileExtension, file.Name)); continue; } int?transactionId = Path.GetFileNameWithoutExtension(file.Name).AsType <int?>(); if (transactionId != null && transactionIdList.ContainsKey((int)transactionId)) { var rockFile = new Rock.Model.BinaryFile(); rockFile.IsSystem = false; rockFile.IsTemporary = false; rockFile.FileName = file.Name; rockFile.BinaryFileTypeId = transactionImageType.Id; rockFile.CreatedDateTime = file.LastWriteTime.DateTime; rockFile.MimeType = Extensions.GetMIMEType(file.Name); rockFile.Description = string.Format("Imported as {0}", file.Name); rockFile.SetStorageEntityTypeId(transactionImageType.StorageEntityTypeId); rockFile.StorageEntitySettings = emptyJsonObject; if (transactionImageType.AttributeValues.Any()) { rockFile.StorageEntitySettings = transactionImageType.AttributeValues .ToDictionary(a => a.Key, v => v.Value.Value).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using (var fileContent = new StreamReader(file.Open())) { rockFile.ContentStream = new MemoryStream(fileContent.BaseStream.ReadBytesToEnd()); } newFileList.Add(transactionIdList[(int)transactionId], rockFile); completed++; if (completed % percentage < 1) { int percentComplete = completed / percentage; ReportProgress(percentComplete, string.Format("{0:N0} files imported ({1}% complete).", completed, percentComplete)); } else if (completed % ReportingNumber < 1) { SaveFiles(newFileList, storageProvider); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if (newFileList.Any()) { SaveFiles(newFileList, storageProvider); } ReportProgress(100, string.Format("Finished files import: {0:N0} addresses imported.", completed)); }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="personImageType">Type of the person image file.</param> /// <param name="storageProvider">The storage provider.</param> public void Map( ZipArchive folder, BinaryFileType personImageType, ProviderComponent storageProvider ) { // check for existing images var lookupContext = new RockContext(); var existingImageList = new PersonService( lookupContext ).Queryable().AsNoTracking() .Where( p => p.Photo != null ) .ToDictionary( p => p.Id, p => p.Photo.CreatedDateTime ); var emptyJsonObject = "{}"; var newFileList = new Dictionary<int, Rock.Model.BinaryFile>(); int completed = 0; int totalRows = folder.Entries.Count; int percentage = ( totalRows - 1 ) / 100 + 1; ReportProgress( 0, string.Format( "Verifying files import ({0:N0} found.", totalRows ) ); foreach ( var file in folder.Entries ) { var fileExtension = Path.GetExtension( file.Name ); if ( BinaryFileComponent.FileTypeBlackList.Contains( fileExtension ) ) { LogException( "Binary File Import", string.Format( "{0} filetype not allowed ({1})", fileExtension, file.Name ) ); continue; } var personForeignId = Path.GetFileNameWithoutExtension( file.Name ).AsType<int?>(); var personKeys = BinaryFileComponent.ImportedPeople.FirstOrDefault( p => p.IndividualId == personForeignId ); if ( personKeys != null ) { // only import the most recent profile photo if ( !existingImageList.ContainsKey( personKeys.PersonId ) || existingImageList[personKeys.PersonId].Value < file.LastWriteTime.DateTime ) { var rockFile = new Rock.Model.BinaryFile(); rockFile.IsSystem = false; rockFile.IsTemporary = false; rockFile.FileName = file.Name; rockFile.BinaryFileTypeId = personImageType.Id; rockFile.MimeType = Extensions.GetMIMEType( file.Name ); rockFile.CreatedDateTime = file.LastWriteTime.DateTime; rockFile.ModifiedDateTime = ImportDateTime; rockFile.Description = string.Format( "Imported as {0}", file.Name ); rockFile.SetStorageEntityTypeId( personImageType.StorageEntityTypeId ); rockFile.StorageEntitySettings = emptyJsonObject; if ( personImageType.AttributeValues.Any() ) { rockFile.StorageEntitySettings = personImageType.AttributeValues .ToDictionary( a => a.Key, v => v.Value.Value ).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using ( var fileContent = new StreamReader( file.Open() ) ) { rockFile.ContentStream = new MemoryStream( fileContent.BaseStream.ReadBytesToEnd() ); } newFileList.Add( personKeys.PersonId, rockFile ); } completed++; if ( completed % percentage < 1 ) { int percentComplete = completed / percentage; ReportProgress( percentComplete, string.Format( "{0:N0} files imported ({1}% complete).", completed, percentComplete ) ); } else if ( completed % ReportingNumber < 1 ) { SaveFiles( newFileList, storageProvider ); // add image keys to master list foreach ( var newFile in newFileList ) { existingImageList.AddOrReplace( newFile.Key, newFile.Value.CreatedDateTime ); } // Reset batch list newFileList.Clear(); ReportPartialProgress(); } } } if ( newFileList.Any() ) { SaveFiles( newFileList, storageProvider ); } ReportProgress( 100, string.Format( "Finished files import: {0:N0} addresses imported.", completed ) ); }
/// <summary> /// Updates the document status. /// </summary> /// <param name="signatureDocument">The signature document.</param> /// <param name="tempFolderPath">The temporary folder path.</param> /// <param name="errorMessages">The error messages.</param> /// <returns></returns> public bool UpdateDocumentStatus(SignatureDocument signatureDocument, string tempFolderPath, out List <string> errorMessages) { errorMessages = new List <string>(); if (signatureDocument == null) { errorMessages.Add("Invalid Document."); } if (signatureDocument.SignatureDocumentTemplate == null) { errorMessages.Add("Document has an invalid document type."); } if (!errorMessages.Any()) { var provider = DigitalSignatureContainer.GetComponent(signatureDocument.SignatureDocumentTemplate.ProviderEntityType.Name); if (provider == null || !provider.IsActive) { errorMessages.Add("Digital Signature provider was not found or is not active."); } else { var originalStatus = signatureDocument.Status; if (provider.UpdateDocumentStatus(signatureDocument, out errorMessages)) { if (signatureDocument.Status == SignatureDocumentStatus.Signed && !signatureDocument.BinaryFileId.HasValue) { using (var rockContext = new RockContext()) { string documentPath = provider.GetDocument(signatureDocument, tempFolderPath, out errorMessages); if (!string.IsNullOrWhiteSpace(documentPath)) { var binaryFileService = new BinaryFileService(rockContext); BinaryFile binaryFile = new BinaryFile(); binaryFile.Guid = Guid.NewGuid(); binaryFile.IsTemporary = false; binaryFile.BinaryFileTypeId = signatureDocument.SignatureDocumentTemplate.BinaryFileTypeId; binaryFile.MimeType = "application/pdf"; var fi = new FileInfo(documentPath); binaryFile.FileName = fi.Name; binaryFile.FileSize = fi.Length; binaryFile.ContentStream = new FileStream(documentPath, FileMode.Open); binaryFileService.Add(binaryFile); rockContext.SaveChanges(); signatureDocument.BinaryFileId = binaryFile.Id; File.Delete(documentPath); } } } if (signatureDocument.Status != originalStatus) { signatureDocument.LastStatusDate = RockDateTime.Now; } } } } return(!errorMessages.Any()); }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="ministryFileType">Type of the ministry file.</param> /// <param name="storageProvider">The storage provider.</param> public void Map(ZipArchive folder, BinaryFileType ministryFileType, ProviderComponent storageProvider) { var lookupContext = new RockContext(); var personEntityTypeId = EntityTypeCache.GetId <Person>(); var fileFieldTypeId = FieldTypeCache.Read(Rock.SystemGuid.FieldType.FILE.AsGuid(), lookupContext).Id; var existingAttributes = new AttributeService(lookupContext).GetByFieldTypeId(fileFieldTypeId) .Where(a => a.EntityTypeId == personEntityTypeId) .ToDictionary(a => a.Key, a => a.Id); var emptyJsonObject = "{}"; var newFileList = new List <DocumentKeys>(); int completed = 0; int totalRows = folder.Entries.Count; int percentage = (totalRows - 1) / 100 + 1; ReportProgress(0, string.Format("Verifying files import ({0:N0} found.", totalRows)); foreach (var file in folder.Entries) { var fileExtension = Path.GetExtension(file.Name); var fileMimeType = Extensions.GetMIMEType(file.Name); if (BinaryFileComponent.FileTypeBlackList.Contains(fileExtension)) { LogException("Binary File Import", string.Format("{0} filetype not allowed ({1})", fileExtension, file.Name)); continue; } else if (fileMimeType == null) { LogException("Binary File Import", string.Format("{0} filetype not recognized ({1})", fileExtension, file.Name)); continue; } string[] parsedFileName = file.Name.Split('_'); // Ministry docs should follow this pattern: // 0. Firstname // 1. Lastname // 2. ForeignId // 3. Filename var personForeignId = parsedFileName[2].AsType <int?>(); var personKeys = BinaryFileComponent.ImportedPeople.FirstOrDefault(p => p.IndividualId == personForeignId); if (personKeys != null) { var rockFile = new Rock.Model.BinaryFile(); rockFile.IsSystem = false; rockFile.IsTemporary = false; rockFile.FileName = file.Name; rockFile.MimeType = fileMimeType; rockFile.BinaryFileTypeId = ministryFileType.Id; rockFile.CreatedDateTime = file.LastWriteTime.DateTime; rockFile.ModifiedDateTime = ImportDateTime; rockFile.Description = string.Format("Imported as {0}", file.Name); rockFile.SetStorageEntityTypeId(ministryFileType.StorageEntityTypeId); rockFile.StorageEntitySettings = emptyJsonObject; if (ministryFileType.AttributeValues.Any()) { rockFile.StorageEntitySettings = ministryFileType.AttributeValues .ToDictionary(a => a.Key, v => v.Value.Value).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using (var fileContent = new StreamReader(file.Open())) { rockFile.ContentStream = new MemoryStream(fileContent.BaseStream.ReadBytesToEnd()); } var attributePattern = "[A-Za-z0-9-]+"; var attributeName = Regex.Match(parsedFileName[3].RemoveWhitespace(), attributePattern); var attributeKey = attributeName.Value.RemoveWhitespace(); // change key to default key for Background Check Documents if (attributeKey == "BackgroundCheck") { attributeKey = "BackgroundCheckDocument"; } if (!existingAttributes.ContainsKey(attributeKey)) { var newAttribute = new Attribute(); newAttribute.FieldTypeId = fileFieldTypeId; newAttribute.EntityTypeId = personEntityTypeId; newAttribute.EntityTypeQualifierColumn = string.Empty; newAttribute.EntityTypeQualifierValue = string.Empty; newAttribute.Key = attributeKey; newAttribute.Name = attributeName.Value; newAttribute.Description = attributeName.Value + " created by binary file import"; newAttribute.CreatedDateTime = ImportDateTime; newAttribute.ModifiedDateTime = ImportDateTime; newAttribute.IsGridColumn = false; newAttribute.IsMultiValue = false; newAttribute.IsRequired = false; newAttribute.AllowSearch = false; newAttribute.IsSystem = false; newAttribute.Order = 0; newAttribute.AttributeQualifiers.Add(new AttributeQualifier() { Key = "binaryFileType", Value = ministryFileType.Guid.ToString() }); lookupContext.Attributes.Add(newAttribute); lookupContext.SaveChanges(); existingAttributes.Add(newAttribute.Key, newAttribute.Id); } newFileList.Add(new DocumentKeys() { PersonId = personKeys.PersonId, AttributeId = existingAttributes[attributeKey], File = rockFile }); completed++; if (completed % percentage < 1) { int percentComplete = completed / percentage; ReportProgress(percentComplete, string.Format("{0:N0} files imported ({1}% complete).", completed, percentComplete)); } else if (completed % ReportingNumber < 1) { SaveFiles(newFileList, storageProvider); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if (newFileList.Any()) { SaveFiles(newFileList, storageProvider); } ReportProgress(100, string.Format("Finished files import: {0:N0} addresses imported.", completed)); }
/// <summary> /// Maps the specified folder. /// </summary> /// <param name="folder">The folder.</param> /// <param name="transactionImageType">Type of the transaction image file.</param> /// <param name="storageProvider">The storage provider.</param> public void Map( ZipArchive folder, BinaryFileType transactionImageType, ProviderComponent storageProvider ) { var lookupContext = new RockContext(); var emptyJsonObject = "{}"; var newFileList = new Dictionary<int, Rock.Model.BinaryFile>(); var transactionIdList = new FinancialTransactionService( lookupContext ) .Queryable().AsNoTracking().Where( t => t.ForeignId != null ) .ToDictionary( t => (int)t.ForeignId, t => t.Id ); int completed = 0; int totalRows = folder.Entries.Count; int percentage = ( totalRows - 1 ) / 100 + 1; ReportProgress( 0, string.Format( "Verifying files import ({0:N0} found.", totalRows ) ); foreach ( var file in folder.Entries ) { var fileExtension = Path.GetExtension( file.Name ); var fileMimeType = Extensions.GetMIMEType( file.Name ); if ( BinaryFileComponent.FileTypeBlackList.Contains( fileExtension ) ) { LogException( "Binary File Import", string.Format( "{0} filetype not allowed ({1})", fileExtension, file.Name ) ); continue; } else if ( fileMimeType == null ) { LogException( "Binary File Import", string.Format( "{0} filetype not recognized ({1})", fileExtension, file.Name ) ); continue; } int? transactionId = Path.GetFileNameWithoutExtension( file.Name ).AsType<int?>(); if ( transactionId != null && transactionIdList.ContainsKey( (int)transactionId ) ) { var rockFile = new Rock.Model.BinaryFile(); rockFile.IsSystem = false; rockFile.IsTemporary = false; rockFile.FileName = file.Name; rockFile.MimeType = fileMimeType; rockFile.BinaryFileTypeId = transactionImageType.Id; rockFile.CreatedDateTime = file.LastWriteTime.DateTime; rockFile.ModifiedDateTime = ImportDateTime; rockFile.Description = string.Format( "Imported as {0}", file.Name ); rockFile.SetStorageEntityTypeId( transactionImageType.StorageEntityTypeId ); rockFile.StorageEntitySettings = emptyJsonObject; if ( transactionImageType.AttributeValues.Any() ) { rockFile.StorageEntitySettings = transactionImageType.AttributeValues .ToDictionary( a => a.Key, v => v.Value.Value ).ToJson(); } // use base stream instead of file stream to keep the byte[] // NOTE: if byte[] converts to a string it will corrupt the stream using ( var fileContent = new StreamReader( file.Open() ) ) { rockFile.ContentStream = new MemoryStream( fileContent.BaseStream.ReadBytesToEnd() ); } newFileList.Add( transactionIdList[(int)transactionId], rockFile ); completed++; if ( completed % percentage < 1 ) { int percentComplete = completed / percentage; ReportProgress( percentComplete, string.Format( "{0:N0} files imported ({1}% complete).", completed, percentComplete ) ); } else if ( completed % ReportingNumber < 1 ) { SaveFiles( newFileList, storageProvider ); // Reset list newFileList.Clear(); ReportPartialProgress(); } } } if ( newFileList.Any() ) { SaveFiles( newFileList, storageProvider ); } ReportProgress( 100, string.Format( "Finished files import: {0:N0} addresses imported.", completed ) ); }