/// <summary> /// Generate a URL for the file based on the rules of the StorageProvider /// </summary> /// <param name="file">The file.</param> /// <returns></returns> public override string GenerateUrl( BinaryFile file ) { if ( string.IsNullOrWhiteSpace( file.FileName ) ) { return null; } var urlBuilder = new StringBuilder(); string rootPath = GetRootPath( file.BinaryFileTypeId ?? 0 ); urlBuilder.Append( rootPath ); if ( !rootPath.EndsWith( "/" ) ) { urlBuilder.Append( "/" ); } // if the file doesn't have a folderPath, prefix the FileName on disk with the Guid so that we can have multiple files with the same name (for example, setup.exe and setup.exe) if ( Path.GetDirectoryName( file.FileName ) == string.Empty ) { urlBuilder.Append( file.Guid + "_" ); } string urlFileName = file.FileName.Replace( "\\", "/" ).TrimStart( new char[] { '/' } ); urlBuilder.Append( urlFileName ); return urlBuilder.ToString(); }
public int? SavePersonPhoto( string fileName, string mimeType, string description, byte[] content, bool isSystem = false, bool isTemporary = false, string foreignId = null ) { BinaryFile binaryFile = new BinaryFile(); binaryFile.FileName = fileName; binaryFile.BinaryFileTypeId = new BinaryFileTypeMap(Service).GetPhotoBinaryFileType().Id; binaryFile.Url = string.Format( "~/GetImage.ashx?guid={0}", binaryFile.Guid ); binaryFile.IsSystem = false; binaryFile.MimeType = mimeType; binaryFile.Description = description; binaryFile.IsTemporary = isTemporary; binaryFile.ForeignId = foreignId; BinaryFileController fileController = new BinaryFileController( Service ); fileController.Add( binaryFile ); binaryFile = fileController.GetByGuid(binaryFile.Guid); binaryFile.Data = new BinaryFileData(); binaryFile.Data.Content = content; binaryFile.Data.Id = binaryFile.Id; BinaryFileDataController fileDataController = new BinaryFileDataController( Service ); fileDataController.Add( binaryFile.Data ); return binaryFile.Id; }
/// <summary> /// Deletes the content from the external storage medium associated with the provider. /// </summary> /// <param name="binaryFile">The binary file.</param> public override void DeleteContent( BinaryFile binaryFile ) { var file = new FileInfo( GetFilePath( binaryFile ) ); if ( file.Exists ) { file.Delete(); } }
/// <summary> /// Gets the contents from the external storage medium associated with the provider /// </summary> /// <param name="file">The file.</param> /// <returns></returns> public override Stream GetContentStream( BinaryFile file ) { if ( file.DatabaseData != null && file.DatabaseData.Content != null ) { return new MemoryStream( file.DatabaseData.Content ); } return new MemoryStream(); }
/// <summary> /// Removes the file from the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> /// <param name="context">The context.</param> public override void RemoveFile( BinaryFile file, HttpContext context ) { var physicalPath = GetPhysicalPath( file.Url, context ); if ( File.Exists( physicalPath ) ) { File.Delete( physicalPath ); } }
/// <summary> /// Gets the file content from storage provider. /// </summary> /// <param name="binaryFile">The binary file.</param> private void GetFileContentFromStorageProvider( BinaryFile binaryFile ) { Rock.Storage.ProviderComponent storageProvider = BinaryFileService.DetermineBinaryFileStorageProvider( (Rock.Data.RockContext)Context, binaryFile ); if ( storageProvider != null ) { binaryFile.Data = binaryFile.Data ?? new BinaryFileData(); binaryFile.Data.Content = storageProvider.GetFileContent( binaryFile, HttpContext.Current ); } }
/// <summary> /// Gets the contents from the external storage medium associated with the provider /// </summary> /// <param name="binaryFile">The binary file.</param> /// <returns></returns> public override Stream GetContentStream( BinaryFile binaryFile ) { var file = new FileInfo( GetFilePath( binaryFile ) ); if ( file.Exists ) { return file.OpenRead(); } return new MemoryStream(); }
/// <summary> /// Shows the detail. /// </summary> /// <param name="binaryFile">The binary file.</param> public void ShowBinaryFileDetail( BinaryFile binaryFile ) { pnlDetails.Visible = true; hfBinaryFileId.SetValue( binaryFile.Id ); if ( binaryFile.BinaryFileTypeId.HasValue ) { fsFile.BinaryFileTypeGuid = new BinaryFileTypeService( new RockContext() ).Get( binaryFile.BinaryFileTypeId.Value ).Guid; } tbName.Text = binaryFile.FileName; tbDescription.Text = binaryFile.Description; tbMimeType.Text = binaryFile.MimeType; ddlBinaryFileType.SetValue( binaryFile.BinaryFileTypeId ); btnEditLabelContents.Visible = fsFile.BinaryFileId.HasValue && !string.IsNullOrWhiteSpace( GetAttributeValue( "EditLabelPage" ) ) && fsFile.BinaryFileTypeGuid == Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL.AsGuid(); Guid? workflowTypeGuid = GetAttributeValue( "Workflow" ).AsGuidOrNull(); btnRerunWorkflow.Visible = workflowTypeGuid.HasValue; // render UI based on Authorized and IsSystem bool readOnly = false; nbEditModeMessage.Text = string.Empty; if ( !IsUserAuthorized( Authorization.EDIT ) ) { readOnly = true; nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( BinaryFile.FriendlyTypeName ); } phAttributes.Controls.Clear(); if ( readOnly ) { lActionTitle.Text = ActionTitle.View( BinaryFile.FriendlyTypeName ); btnCancel.Text = "Close"; Rock.Attribute.Helper.AddDisplayControls( binaryFile, phAttributes ); fsFile.Enabled = false; fsFile.Label = "View File"; } else { Rock.Attribute.Helper.AddEditControls( binaryFile, phAttributes, true, BlockValidationGroup ); } tbName.ReadOnly = readOnly; tbDescription.ReadOnly = readOnly; tbMimeType.ReadOnly = readOnly; ddlBinaryFileType.Enabled = !readOnly; btnSave.Visible = !readOnly; }
/// <summary> /// Gets the file bytes from the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> /// <param name="context">The context.</param> /// <returns></returns> public override byte[] GetFileContent( BinaryFile file, HttpContext context ) { if (file.Data != null) { return file.Data.Content; } else { return null; } }
/// <summary> /// Saves the binary file contents to the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> public override void SaveContent( BinaryFile file ) { if ( file.DatabaseData == null ) { file.DatabaseData = new BinaryFileData(); } using ( var stream = file.ContentStream ) { file.DatabaseData.Content = stream.ReadBytesToEnd(); } }
/// <summary> /// Gets the file bytes from the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> /// <param name="context">The context.</param> /// <returns></returns> public override byte[] GetFileContent( BinaryFile file, HttpContext context ) { var physicalPath = GetPhysicalPath( file.Url, context ); if ( File.Exists( physicalPath ) ) { return File.ReadAllBytes( physicalPath ); } else { return null; } }
public static void OpenBinaryFile(string binaryFile, string grammarFile, string comparisonFile) { BinaryFile file = new BinaryFile(binaryFile); List<byte[]> interestingBytes = FilterController.Filter(binaryFile, comparisonFile); string outputFile = @"Y:\092010\output_binary.bin"; using (var stream = File.Create(outputFile)) { for (int i = 0; i < interestingBytes.Count; i++) { stream.Write(interestingBytes[i], 0, interestingBytes[i].Length); } } List<byte[]> interestingBytes2 = FilterController.Filter(comparisonFile, binaryFile); string outputFile2 = @"Y:\092010\output_comparision.bin"; using (var stream = File.Create(outputFile2)) { for (int i = 0; i < interestingBytes2.Count; i++) { stream.Write(interestingBytes2[i], 0, interestingBytes2[i].Length); } } return; int windowSize = 300; int shiftAmount = 50; Grammar grammar = new Grammar(grammarFile); ProcessWindow(interestingBytes, grammar); //string startOffsetS = "01d70300"; //Int64 startOffsetI = Convert.ToInt64(startOffsetS, 16); //List<long> startIndexes = new List<long>(); //for (long i = startOffsetI; i < file.Info.Length-windowSize; i+=shiftAmount) //{ // startIndexes.Add(i); //} //Parallel.For(0, startIndexes.Count, i => ProcessWindow(file, grammar, startIndexes[i],i)); }
/// <summary> /// Gets the contents from the external storage medium associated with the provider /// </summary> /// <param name="binaryFile">The binary file.</param> /// <returns></returns> public override Stream GetContentStream( BinaryFile binaryFile ) { string filePath = GetFilePath( binaryFile ); if ( !string.IsNullOrWhiteSpace( filePath ) ) { var file = new FileInfo( GetFilePath( binaryFile ) ); if ( file.Exists ) { return file.OpenRead(); } } return new MemoryStream(); }
/// <summary> /// Determines the storage provider that was used the last time the file was saved /// </summary> /// <param name="dbContext">The database context.</param> /// <param name="item">The item.</param> /// <returns></returns> public static Storage.ProviderComponent DetermineBinaryFileStorageProvider( Rock.Data.RockContext dbContext, BinaryFile item ) { Rock.Storage.ProviderComponent storageProvider = null; if ( item != null ) { item.StorageEntityType = item.StorageEntityType ?? new EntityTypeService( dbContext ).Get( item.StorageEntityTypeId ?? 0 ); if ( item.StorageEntityType != null ) { storageProvider = Rock.Storage.ProviderContainer.GetComponent( item.StorageEntityType.Name ); } } return storageProvider; }
internal static RenderedNode getNodeFromBinaryFile(BinaryFile binaryFile) { RenderedNode node = RenderedNode.CreateDefault(); node.TechnicalSource = NodeSourceTypeBinaryFile; node.Title = binaryFile.Title; node.Excerpt = binaryFile.Description; node.ActualContentUrl = binaryFile.Data != null ? binaryFile.Data.ContentUrl : null; if (binaryFile.Categories != null) { node.Categories.CollectionContent.AddRange(getCategoryCollectionTexts(binaryFile.Categories, getTitleOrNameFromCategory)); node.CategoryNames.CollectionContent.AddRange(getCategoryCollectionTexts(binaryFile.Categories, cat => cat.CategoryName)); node.CategoryIDList = binaryFile.Categories.SelectedIDCommaSeparated; } return node; }
/// <summary> /// Shows the detail. /// </summary> /// <param name="binaryFile">The binary file.</param> public void ShowBinaryFileDetail( BinaryFile binaryFile ) { pnlDetails.Visible = true; hfBinaryFileId.SetValue( binaryFile.Id ); if ( binaryFile.BinaryFileTypeId.HasValue ) { fsFile.BinaryFileTypeGuid = new BinaryFileTypeService( new RockContext() ).Get( binaryFile.BinaryFileTypeId.Value ).Guid; } tbName.Text = binaryFile.FileName; tbDescription.Text = binaryFile.Description; tbMimeType.Text = binaryFile.MimeType; ddlBinaryFileType.SetValue( binaryFile.BinaryFileTypeId ); // render UI based on Authorized and IsSystem bool readOnly = false; nbEditModeMessage.Text = string.Empty; if ( !IsUserAuthorized( Authorization.EDIT ) ) { readOnly = true; nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed( BinaryFile.FriendlyTypeName ); } phAttributes.Controls.Clear(); if ( readOnly ) { lActionTitle.Text = ActionTitle.View( BinaryFile.FriendlyTypeName ); btnCancel.Text = "Close"; Rock.Attribute.Helper.AddDisplayControls( binaryFile, phAttributes ); fsFile.Enabled = false; fsFile.Label = "View File"; } else { Rock.Attribute.Helper.AddEditControls( binaryFile, phAttributes, true ); } tbName.ReadOnly = readOnly; tbDescription.ReadOnly = readOnly; tbMimeType.ReadOnly = readOnly; ddlBinaryFileType.Enabled = !readOnly; btnSave.Visible = !readOnly; }
public static void Read16Bit(BinaryFile wavfile, double[][] sound, int samplecount, int channels) { int i = 0; int ic = 0; #if DEBUG Console.Write("Read16Bit...\n"); #endif for (i = 0; i<samplecount; i++) { for (ic = 0; ic<channels; ic++) { double d = (double) wavfile.ReadInt16(); d = d / 32768.0; sound[ic][i] = d; } } }
/// <summary> /// Gets the path. /// </summary> /// <param name="file">The file.</param> /// <returns></returns> public virtual string GetPath( BinaryFile file ) { string url = string.Empty; if ( file != null ) { url = "~/GetFile.ashx"; if ( file.MimeType != null && file.MimeType.StartsWith( "image/", StringComparison.OrdinalIgnoreCase ) ) { url = "~/GetImage.ashx"; } url += "?guid=" + file.Guid.ToString(); } return url; }
public static void Read32BitFloat(BinaryFile wavfile, double[][] sound, int samplecount, int channels) { int i = 0; int ic = 0; #if DEBUG Console.Write("Read32BitFloat...\n"); #endif for (i = 0;i<samplecount;i++) { for (ic = 0;ic<channels;ic++) { double d = (double) wavfile.ReadSingle(); sound[ic][i] = d; } } }
/// <summary> /// Generate a URL for the file based on the rules of the StorageProvider /// </summary> /// <param name="file">The file.</param> /// <returns></returns> public override string GenerateUrl( BinaryFile file) { string urlPath; switch ( file.MimeType.ToLower() ) { case "image/jpeg": case "image/gif": case "image/png": case "image/bmp": urlPath = "~/GetImage.ashx"; break; default: urlPath = "~/GetFile.ashx"; break; } return string.Format( "{0}?guid={1}", urlPath, file.Guid ); }
public Stream Load(BinaryFile file) { var content = binaryFileContentRepository.GetByBinaryFile(file); if (content == null || content.Content == null) { return(null); } var path = Path.GetTempFileName(); var fileName = Path.GetFileNameWithoutExtension(path); var extension = Path.GetExtension(file.Name); var fullPath = Path.Combine(Path.GetDirectoryName(path), $"{fileName}{extension}"); using (var stream = new FileStream(fullPath, FileMode.CreateNew)) { stream.Write(content.Content, 0, content.Content.Length); } return(new FileStream(fullPath, FileMode.Open)); }
public static void SaveProjectile(int ProjectileNum) { string filename; filename = Path.Combine(Application.StartupPath, "data", "projectiles", string.Format("projectile{0}.dat", ProjectileNum)); ByteStream writer = new ByteStream(100); writer.WriteString(Projectiles[ProjectileNum].Name); writer.WriteInt32(Projectiles[ProjectileNum].Sprite); writer.WriteByte(Projectiles[ProjectileNum].Range); writer.WriteInt32(Projectiles[ProjectileNum].Speed); writer.WriteInt32(Projectiles[ProjectileNum].Damage); //Logic writer.WriteString(Projectiles[ProjectileNum].OnInstantiate); writer.WriteString(Projectiles[ProjectileNum].OnUpdate); writer.WriteString(Projectiles[ProjectileNum].OnHitWall); writer.WriteString(Projectiles[ProjectileNum].OnHitEntity); BinaryFile.Save(filename, ref writer); }
/// <summary> /// Gets from binary file service. /// </summary> /// <param name="context">The context.</param> /// <param name="fileId">The file identifier.</param> /// <param name="fileGuid">The file unique identifier.</param> /// <returns></returns> private BinaryFile GetFromBinaryFileService(HttpContext context, int fileId, RockContext rockContext) { BinaryFile binaryFile = null; System.Threading.ManualResetEvent completedEvent = new ManualResetEvent(false); // use the binaryFileService.BeginGet/EndGet which is a little faster than the regular get AsyncCallback cb = ( IAsyncResult asyncResult ) => { // restore the context from the asyncResult.AsyncState HttpContext asyncContext = ( HttpContext )asyncResult.AsyncState; binaryFile = new BinaryFileService(rockContext).EndGet(asyncResult, context); completedEvent.Set(); }; IAsyncResult beginGetResult = new BinaryFileService(rockContext).BeginGet(cb, context, fileId); // wait up to 5 minutes for the response completedEvent.WaitOne(300000); return(binaryFile); }
/// <summary> /// Sets the value. /// </summary> /// <param name="control">The control.</param> /// <param name="configurationValues"></param> /// <param name="value">The value.</param> public override void SetEditValue(Control control, Dictionary <string, ConfigurationValue> configurationValues, string value) { var picker = control as BinaryFilePicker; if (picker != null) { BinaryFile binaryFile = null; Guid? guid = value.AsGuidOrNull(); // get the item (or null) and set it if (guid.HasValue) { using (var rockContext = new RockContext()) { binaryFile = new BinaryFileService(rockContext).Get(guid.Value); } } picker.SetValue(binaryFile); } }
public static void Main(string[] args) { string inLeft = @"F:\SAMPLES\IMPULSE RESPONSES\PER IVAR IR SAMPLES\ALTIVERB-QUAD-IMPULSE-RESPONSES\Scoring Stages (Orchestral Studios)_Todd-AO - California US_st to st wide mics at 18m90_L.wav"; string inRight = @"F:\SAMPLES\IMPULSE RESPONSES\PER IVAR IR SAMPLES\ALTIVERB-QUAD-IMPULSE-RESPONSES\Scoring Stages (Orchestral Studios)_Todd-AO - California US_st to st wide mics at 18m90_R.wav"; float[] channel1; float[] channel2; float[] channel3; float[] channel4; AudioUtilsNAudio.SplitStereoWaveFileToMono(inLeft, out channel1, out channel2); AudioUtilsNAudio.SplitStereoWaveFileToMono(inRight, out channel3, out channel4); // find out what channel is longest int maxLength = Math.Max(channel1.Length, channel3.Length); string outputFile = @"Scoring Stages (Orchestral Studios)_Todd-AO - California US_st to st wide mics at 18m90V2.sir"; //string cfh_data = @"abe6f4214362.34U4T9yaBCCDEuyH0uCm7T6Pf.z+PqR.kBAoHEfz3DlPB4lX.K4XirMP+3WCzJZ6RYE0ka38ty94e5j858dEG1RUZlT3iZV2EATQgrjIV5ixyF5zA0qasZdXlJpZ8FtlNjwomlnU8lHn+JhPP48khE9n1HPSpVyoJhg5itqiqqKp600.vKJEevIQJ4fXS0aTksgilV6fMkL4wNFPLDn33w5irgZ7lpiNZaJe791OXu1ATcghs1bHHwzElL49JBlnXKYBBeeT8QCedFNXTRbHdVznj7XbHjFhSlLFaURBSgnoA1RJ7UWAwYQSCSew407fANeNiyoYvERkkO.1PVR0vMSTEqnZihvsR6eC5ammIKKcBl.NPeBmsPpDLBjimqMfQB15NVIEpXEZfXflcpdxcd77xh56HaQM9Shz7rIRJa4p+EHo0YfjCv3BeKI87QR6yGIW1qI+hIdM99OMVIuF+7+KqzUe.bo2V9C"; string cfh_data = @"abe6f42143 "; BinaryFile binaryFile = new BinaryFile(outputFile, BinaryFile.ByteOrder.LittleEndian, true); binaryFile.Write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>"); binaryFile.Write("\n\n"); binaryFile.Write("<SirImpulseFile version=\"2.1\" cfh_data=\""); binaryFile.Write(cfh_data); binaryFile.Write("\"/>"); binaryFile.Write("\r\n"); binaryFile.Write((byte)0); WriteAudioBlock(binaryFile, channel1, maxLength, "0"); WriteAudioBlock(binaryFile, channel2, maxLength, "1"); WriteAudioBlock(binaryFile, channel3, maxLength, "2"); WriteAudioBlock(binaryFile, channel4, maxLength, "3"); binaryFile.Close(); Console.Write("Press any key to continue . . . "); Console.ReadKey(true); }
public void UploadFile(BinaryFile file) { DataFileModel model = new DataFileModel(); model.Date = file.Date; model.User.Id = file.User.Id; model.Path = FileManager.GetFileManager().SaveSessionsFile(file); GlobalConfig.Connection.File_Insert(model); var sessions = BinaryConnector.StaticLoad <List <AppSession> >(model.Path); foreach (var session in sessions) { if (session.MouseData != null && session.EndTime != DateTime.MinValue) { AppModel appModel = new AppModel(); appModel.ProcessName = session.App.ProcessName; GlobalConfig.Connection.App_Insert(appModel); SessionModel sessionModel = new SessionModel(); sessionModel.AppId = appModel.Id; sessionModel.BackspaceStrokesCount = session.KeyboardData.BackspaceStrokesCount; sessionModel.StrokesCount = session.KeyboardData.StrokesCount; sessionModel.StrokeHoldTimes = session.KeyboardData.StrokeHoldTimes; sessionModel.UniqueKeysCount = session.KeyboardData.UniqueKeysCount; sessionModel.MouseClickCount = (int)session.MouseData.MouseClickCount; sessionModel.MouseClickTotalTime = (int)session.MouseData.MouseClickTotalTime; sessionModel.StartTime = session.StartTime; sessionModel.EndTime = session.EndTime; sessionModel.UserId = model.User.Id; sessionModel.AppId = appModel.Id; GlobalConfig.Connection.Session_Insert(sessionModel); if (session.App.Type == HRPMSharedLibrary.Enums.AppType.Browser) { DomainModel domainModel = new DomainModel(); domainModel.Domain = session.App.Content; GlobalConfig.Connection.Domain_Insert(domainModel); GlobalConfig.Connection.SessionDomain_Insert(sessionModel.Id, domainModel.Id); } } } }
public override bool Execute(RockContext rockContext, WorkflowAction action, object entity, out List <string> errorMessages) { SignatureDocumentService signatureDocumentService = new SignatureDocumentService(rockContext); BinaryFileService binaryfileService = new BinaryFileService(rockContext); PersonAliasService personAliasService = new PersonAliasService(rockContext); errorMessages = new List <string>(); // Get all the attribute values var mergeFields = GetMergeFields(action); int documentTemplateId = GetAttributeValue(action, "DocumentTemplateId", true).AsInteger(); Guid documentGuid = action.GetWorklowAttributeValue(GetActionAttributeValue(action, "Document").AsGuid()).AsGuid(); BinaryFile binaryFile = binaryfileService.Get(documentGuid); string documentKey = GetAttributeValue(action, "DocumentKey", true).ResolveMergeFields(mergeFields); string documentName = GetAttributeValue(action, "DocumentName", true).ResolveMergeFields(mergeFields); Guid assignedTo = GetAttributeValue(action, "AssignedTo", true).AsGuid(); Guid appliesTo = GetAttributeValue(action, "AppliesTo", true).AsGuid(); Guid signedBy = GetAttributeValue(action, "SignedBy", true).AsGuid(); if (binaryFile != null) { // Create the signature document Rock.Model.SignatureDocument document = new Rock.Model.SignatureDocument(); document.AssignedToPersonAliasId = personAliasService.Get(assignedTo).Id; document.AppliesToPersonAliasId = personAliasService.Get(appliesTo).Id; document.SignedByPersonAliasId = personAliasService.Get(signedBy).Id; document.Name = documentName; document.DocumentKey = documentKey; document.BinaryFileId = binaryFile.Id; document.SignatureDocumentTemplateId = documentTemplateId; document.LastInviteDate = RockDateTime.Now; document.LastStatusDate = RockDateTime.Now; document.Status = SignatureDocumentStatus.Signed; // Add the signature document to the service signatureDocumentService.Add(document); } return(true); }
public static List <SkillData> Load() { try { List <SkillData> CustomDefinitions = new List <SkillData>(); if (Directory.Exists(Dir_Definitions)) { var files = Directory.GetFiles(Dir_Definitions); foreach (var file in files) { bool failed; _SkillData _skilldata = BinaryFile.ReadFromFile <_SkillData>(file, out failed); if (!failed) { SkillData newSkillData = Convert_ToClass(_skilldata); CustomDefinitions.Add(newSkillData); } else { _SkillData_int _skilldata_int = BinaryFile.ReadFromFile <_SkillData_int>(file, out failed); SkillData newSkillData = Convert_ToClass(_skilldata_int); CustomDefinitions.Add(newSkillData); } } } return(CustomDefinitions); } catch { return(new List <SkillData>()); } }
/// <summary> /// Handles the FileUploaded event of the fsFile control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void fsFile_FileUploaded(object sender, EventArgs e) { var rockContext = new RockContext(); var binaryFileService = new BinaryFileService(rockContext); BinaryFile binaryFile = null; if (fsFile.BinaryFileId.HasValue) { binaryFile = binaryFileService.Get(fsFile.BinaryFileId.Value); } if (binaryFile != null) { if (!string.IsNullOrWhiteSpace(tbName.Text)) { binaryFile.FileName = tbName.Text; } // set binaryFile.Id to original id since the UploadedFile is a temporary binaryFile with a different id binaryFile.Id = hfBinaryFileId.ValueAsInt(); binaryFile.Description = tbDescription.Text; binaryFile.BinaryFileTypeId = ddlBinaryFileType.SelectedValueAsInt(); if (binaryFile.BinaryFileTypeId.HasValue) { binaryFile.BinaryFileType = new BinaryFileTypeService(rockContext).Get(binaryFile.BinaryFileTypeId.Value); } var tempList = OrphanedBinaryFileIdList; tempList.Add(fsFile.BinaryFileId.Value); OrphanedBinaryFileIdList = tempList; // load attributes, then get the attribute values from the UI binaryFile.LoadAttributes(); Rock.Attribute.Helper.GetEditValues(phAttributes, binaryFile); LaunchFileUploadWorkflow(binaryFile, binaryFileService); ShowBinaryFileDetail(binaryFile); } }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Load" /> event. /// </summary> /// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnLoad( EventArgs e ) { base.OnLoad( e ); if ( !Page.IsPostBack ) { string itemId = PageParameter( "BinaryFileId" ); string typeId = PageParameter( "BinaryFileTypeId" ); if ( !string.IsNullOrWhiteSpace( itemId ) ) { if ( string.IsNullOrWhiteSpace( typeId ) ) { ShowDetail( "BinaryFileId", int.Parse( itemId ) ); } else { ShowDetail( "BinaryFileId", int.Parse( itemId ), int.Parse( typeId ) ); } } else { pnlDetails.Visible = false; } ddlBinaryFileType.Visible = GetAttributeValue( "ShowBinaryFileType" ).AsBoolean(); } else { if ( pnlDetails.Visible ) { var binaryFile = new BinaryFile { BinaryFileTypeId = ddlBinaryFileType.SelectedValueAsInt() ?? 0 }; if ( binaryFile.BinaryFileTypeId > 0 ) { binaryFile.LoadAttributes(); phAttributes.Controls.Clear(); Rock.Attribute.Helper.AddEditControls( binaryFile, phAttributes, false ); } } } }
/// <summary> /// Shows the detail. /// </summary> /// <param name="itemKey">The item key.</param> /// <param name="itemKeyValue">The item key value.</param> /// <param name="binaryFileTypeId">The binary file type id.</param> public void ShowDetail(string itemKey, int itemKeyValue, int?binaryFileTypeId) { if (!itemKey.Equals("BinaryFileId")) { return; } var binaryFileService = new BinaryFileService(); BinaryFile BinaryFile = null; if (!itemKeyValue.Equals(0)) { BinaryFile = binaryFileService.Get(itemKeyValue); } if (BinaryFile != null) { lActionTitle.Text = ActionTitle.Edit(BinaryFile.BinaryFileType.Name); } else { BinaryFile = new BinaryFile { Id = 0, IsSystem = false, BinaryFileTypeId = binaryFileTypeId }; string friendlyName = BinaryFile.FriendlyTypeName; if (binaryFileTypeId.HasValue) { var binaryFileType = new BinaryFileTypeService().Get(binaryFileTypeId.Value); if (binaryFileType != null) { friendlyName = binaryFileType.Name; } } lActionTitle.Text = ActionTitle.Add(friendlyName); } ShowDetail(BinaryFile); }
private void UpdatePersonPhoto(Rock.Model.Person person, MemoryStream photoData) { RockContext rockContext = new RockContext(); PersonService personService = new PersonService(rockContext); person = personService.Get(person.Id); var binaryFileType = new BinaryFileTypeService(rockContext).GetNoTracking(Rock.SystemGuid.BinaryFiletype.PERSON_IMAGE.AsGuid()); var fileName = person.FullName.RemoveSpaces().MakeValidFileName(); if (fileName.IsNullOrWhiteSpace()) { fileName = "PersonPhoto"; } var binaryFile = new BinaryFile() { FileName = fileName, MimeType = "image/jpeg", BinaryFileTypeId = binaryFileType.Id, IsTemporary = false }; binaryFile.SetStorageEntityTypeId(binaryFileType.StorageEntityTypeId); byte[] photoDataBytes = photoData.ToArray(); binaryFile.FileSize = photoDataBytes.Length; binaryFile.ContentStream = new MemoryStream(photoDataBytes); var binaryFileService = new BinaryFileService(rockContext); binaryFileService.Add(binaryFile); rockContext.SaveChanges(); person.PhotoId = binaryFile.Id; rockContext.SaveChanges(); }
public models Stripify(string filePath) { var stgpv = new Model(); var textures = new MikuMikuLibrary.Textures.TextureSet(); var texdb = new TextureDatabase(); using (var farcArchive = BinaryFile.Load <FarcArchive>(filePath)) { using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txi")).First(), EntryStreamMode.MemoryStream)) texdb.Load(entryStream); using (var entryStream = farcArchive.Open(farcArchive.Entries.Where(c => c.Contains("txd")).First(), EntryStreamMode.MemoryStream)) textures.Load(entryStream); using (var entryStream = farcArchive.Open(farcArchive.Entries.First(), EntryStreamMode.MemoryStream)) stgpv.Load(entryStream, textures, texdb); } foreach (var meshes in stgpv.Meshes) { foreach (var submeshes in meshes.SubMeshes) { foreach (var indexTable in submeshes.IndexTables) { ushort[] triangleStrip = Stripifier.Stripify(indexTable.Indices); if (triangleStrip != null) { indexTable.PrimitiveType = PrimitiveType.TriangleStrip; indexTable.Indices = triangleStrip; } } } } var le_model = new models(); le_model.model = stgpv; le_model.fileName = filePath; Logs.WriteLine("Stripified " + Path.GetFileName(filePath)); return(le_model); }
private void AddDocuments(ref Application application, out bool Valid, IEnumerable <HttpPostedFileBase> docs) { Valid = true; foreach (var f in docs) { if (f != null) { string mimeType = f.ContentType; if (mimeType == "application/pdf" || mimeType == "application/msword" || mimeType == "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || mimeType == "application/vnd.openxmlformats-officedocument.wordprocessingml.template") { Valid = true; string fileName = Path.GetFileName(f.FileName); int fileLength = f.ContentLength; if (!(fileName == "" || fileLength == 0)) { Stream fileStream = f.InputStream; byte[] fileData = new byte[fileLength]; fileStream.Read(fileData, 0, fileLength); BinaryFile newFile = new BinaryFile { FileContent = new FileContent { Content = fileData, MimeType = mimeType }, FileName = fileName }; application.BinaryFiles.Add(newFile); } } else { Valid = false; } } } }
protected void mdEdit_SaveClick(object sender, EventArgs e) { // Save the image // SetAttributeValue("BackgroundImage", imgupTitleBackground.BinaryFileId); SetAttributeValue("TitleText", tbTopperTitle.Text); RockContext rockContext = new RockContext(); BinaryFileService binaryFileService = new BinaryFileService(rockContext); BinaryFile backgroundImage = binaryFileService.Get(imgupTitleBackground.BinaryFileId ?? 0); if (backgroundImage != null) { backgroundImage.IsTemporary = false; rockContext.SaveChanges(); } SetAttributeValue("BackgroundImageId", imgupTitleBackground.BinaryFileId.ToString()); SetAttributeValue("InfoPanelContent", htmlInfoPanelContent.Text); SetAttributeValue("InfoPanelBackgroundRGBValue", cpBackground.Text); SetAttributeValue("InfoPanelVisible", cbInfoPanel.Checked.ToString()); SaveAttributeValues(); mdEdit.Hide(); }
public static void LoadProjectiles() { string filename; int i; CheckProjectile(); for (i = 1; i <= MAX_PROJECTILES; i++) { filename = Path.Combine(Application.StartupPath, "data", "projectiles", string.Format("projectile{0}.dat", i)); ByteStream reader = new ByteStream(); BinaryFile.Load(filename, ref reader); Projectiles[i].Name = reader.ReadString(); Projectiles[i].Sprite = reader.ReadInt32(); Projectiles[i].Range = reader.ReadByte(); Projectiles[i].Speed = reader.ReadInt32(); Projectiles[i].Damage = reader.ReadInt32(); //Application.DoEvents(); } }
private static Entry parse_nimd_entry(BinaryFile bFile) { // read boolean (1 byte) bool isList = bFile.ReadBoolean(); // ready 2 ints (8 bytes) int total_size = bFile.ReadInt32(); int name_size = bFile.ReadInt32(); string name = bFile.ReadString(name_size); if (isList) { return(parse_nimd_entry_list(bFile, name)); } // ready 2 ints (8 bytes) int data_offset = bFile.ReadInt32(); int data_size = bFile.ReadInt32(); return(new Entry(name, data_offset, data_size)); }
/// <summary> /// Saves the data. /// </summary> /// <param name="context">The context.</param> /// <param name="inputStream">The input stream.</param> /// <param name="file">The file.</param> public override void SaveData(HttpContext context, Stream inputStream, BinaryFile file) { // Check to see if we should flip the image. try { Bitmap bmp = new Bitmap(inputStream); var exif = new EXIFextractor(ref bmp, "\n"); if (exif["Orientation"] != null) { RotateFlipType flip = OrientationToFlipType(exif["Orientation"].ToString()); if (flip != RotateFlipType.RotateNoneFlipNone) // don't flip if orientation is correct { bmp.RotateFlip(flip); exif.setTag(0x112, "1"); // reset orientation tag } } if (context.Request.QueryString["enableResize"] != null) { Bitmap resizedBmp = RoughResize(bmp, 1024, 768); bmp = resizedBmp; } using (MemoryStream stream = new MemoryStream()) { bmp.Save(stream, ContentTypeToImageFormat(file.MimeType)); if (file.Data == null) { file.Data = new BinaryFileData(); } file.Data.Content = stream.ToArray(); stream.Close(); } } catch { // TODO: Log unable to rotate and/or resize. } }
private void SetFileSize(BinaryFile file, DevComponents.DotNetBar.LabelX label, bool sizesSame) { if (file == null || !file.IsFileOnDisk) { label.Text = "-"; return; } double numMegaBytes = file.GetFileSize() / (1024d * 1024d); if (numMegaBytes >= 1) label.Text = numMegaBytes + " MB"; else { numMegaBytes = file.GetFileSize() / 1024d; label.Text = numMegaBytes + " kB"; } if (sizesSame) pictureBoxFilesize.Image = System.Drawing.Image.FromStream(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Slyce.IntelliMerge.Resources.font_char61_green_16_h.png")); else pictureBoxFilesize.Image = System.Drawing.Image.FromStream(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Slyce.IntelliMerge.Resources.font_char33_red_16_h.png")); }
/// <summary> /// Extract NI Massive's tables.dat file into a specified output directory /// </summary> /// <param name="tablesDatFilePath">path to tables.dat</param> /// <param name="outputDirPath">path to output directory</param> /// <returns></returns> public static bool Extract(string tablesDatFilePath, string outputDirPath) { if (File.Exists(tablesDatFilePath)) { string fileName = Path.GetFileNameWithoutExtension(tablesDatFilePath); // read in the map to save as NI Massive's GUI filenames var map = MassiveMapping.ReadMassiveMapping("massive_map.csv"); var bFile = new BinaryFile(tablesDatFilePath, BinaryFile.ByteOrder.LittleEndian); Entry nimd = parse_nimd_file(bFile); extract_nimd_entry(bFile, nimd, outputDirPath, outputDirPath, map); bFile.Close(); return(true); } else { return(false); } }
/// <summary> /// 检查序列化文件是否存在,如果存在就读取再保存到access数据库,不存在就new一个新的list /// </summary> private void CheckFileBuff() { try { //检查目录下是否有序列化文件,若存在就反序列化读取,不存在就创new一个新的list if (File.Exists(fileName)) { DataBase.DBHelp.FileName = DataBase.DBHelp.fileName; //指定数据库路径 BinaryFile.FileName = fileName; //指定序列化文件路径 //读取出序列化文件的内容到List表 recLst = BinaryFile.ReadBinary().ConvertAll(s => (Models.DataBaseRecord)s); //读取序列化文件内容到list Models.DataBaseRecord rec = recLst[0]; //获取出列表第一个参数项 List <string> listTem = new List <string>(); //实例化一个类属性让下面SQL语读出查找的项用来做判断 listTem = DataBase.CQServices.GetRecordSql(@"SELECT DataSheet.serialNumber FROM DataSheet WHERE(((DataSheet.serialNumber) = '" + rec.serialNumber + @"'))"); //判断数据库里有无重复编号,有的话就删除,没有就插入 if (listTem.Count > 0) { DataBase.CQServices.DeleteRecord(rec.serialNumber); //删除重复项 } DataBase.CQServices.BulckInsert(recLst); //向ACCESS数据库添加数据列表 File.Delete(fileName); //删除序列化文件 recLst.Clear(); //清空数据列表 } else { recLst.Clear(); } } catch (Exception ex) { CMessageBox.Show(ex.Message, "提示"); return; } }
/// <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 ); }
protected void lbExport_Click(object sender, EventArgs e) { using (var rockContext = new RockContext()) { var batchId = tbBatchId.Text.AsInteger(); var batches = new FinancialBatchService(rockContext).Queryable().Where(b => b.Id == batchId).ToList(); var fileFormat = new ImageCashLetterFileFormatService(rockContext).Get(ddlFileFormat.SelectedValue.AsInteger()); var component = FileFormatTypeContainer.GetComponent(fileFormat.EntityType.Name); List <string> errorMessages; fileFormat.LoadAttributes(rockContext); var mergeFields = new Dictionary <string, object> { { "FileFormat", fileFormat } }; var filename = fileFormat.FileNameTemplate.ResolveMergeFields(mergeFields); var stream = component.ExportBatches(fileFormat, batches, out errorMessages); var binaryFileService = new BinaryFileService(rockContext); var binaryFileTypeService = new BinaryFileTypeService(rockContext); var binaryFile = new BinaryFile { BinaryFileTypeId = binaryFileTypeService.Get(Rock.SystemGuid.BinaryFiletype.DEFAULT.AsGuid()).Id, IsTemporary = true, FileName = filename, MimeType = "octet/stream", ContentStream = stream }; binaryFileService.Add(binaryFile); rockContext.SaveChanges(); pnlSuccess.Visible = true; hlDownload.NavigateUrl = ResolveUrl(string.Format("~/GetFile.ashx?Id={0}&attachment=True", binaryFile.Id)); } }
/// <summary> /// Sends the message. /// </summary> /// <param name="toPersonId">To person identifier.</param> /// <param name="message">The message.</param> /// <param name="newMessage">if set to <c>true</c> [new message].</param> private void SendMessageToPerson(int toPersonId, string message, bool newMessage) { using (var rockContext = new RockContext()) { // The sender is the logged in user. int fromPersonAliasId = CurrentUser.Person.PrimaryAliasId.Value; string fromPersonName = CurrentUser.Person.FullName; // The sending phone is the selected one DefinedValueCache fromPhone = DefinedValueCache.Get(hfSmsNumber.ValueAsInt()); string responseCode = Rock.Communication.Medium.Sms.GenerateResponseCode(rockContext); BinaryFile binaryFile = null; List <BinaryFile> photos = null; if (!newMessage && ImageUploaderConversation.BinaryFileId.IsNotNullOrZero()) { // If this is a response using the conversation window and a photo file has been uploaded then add it binaryFile = new BinaryFileService(rockContext).Get(ImageUploaderConversation.BinaryFileId.Value); } else if (newMessage && ImageUploaderModal.BinaryFileId.IsNotNullOrZero()) { // If this is a new message using the modal and a photo file has been uploaded then add it binaryFile = new BinaryFileService(rockContext).Get(ImageUploaderModal.BinaryFileId.Value); } photos = binaryFile != null ? new List <BinaryFile> { binaryFile } : null; var toPrimaryAliasId = new PersonAliasService(rockContext).GetPrimaryAliasId(toPersonId); // Create and enqueue the communication Rock.Communication.Medium.Sms.CreateCommunicationMobile(CurrentUser.Person, toPrimaryAliasId, message, fromPhone, responseCode, rockContext, photos); ImageUploaderConversation.BinaryFileId = null; } }
public static void SaveAnimation(int AnimationNum) { string filename; int x; filename = Path.Combine(Application.StartupPath, "data", "animations", string.Format("animation{0}.dat", AnimationNum)); ByteStream writer = new ByteStream(100); writer.WriteString(Types.Animation[AnimationNum].Name); writer.WriteString(Types.Animation[AnimationNum].Sound); var loopTo = Information.UBound(Types.Animation[AnimationNum].Sprite); for (x = 0; x <= loopTo; x++) { writer.WriteInt32(Types.Animation[AnimationNum].Sprite[x]); } var loopTo1 = Information.UBound(Types.Animation[AnimationNum].Frames); for (x = 0; x <= loopTo1; x++) { writer.WriteInt32(Types.Animation[AnimationNum].Frames[x]); } var loopTo2 = Information.UBound(Types.Animation[AnimationNum].LoopCount); for (x = 0; x <= loopTo2; x++) { writer.WriteInt32(Types.Animation[AnimationNum].LoopCount[x]); } var loopTo3 = Information.UBound(Types.Animation[AnimationNum].LoopTime); for (x = 0; x <= loopTo3; x++) { writer.WriteInt32(Types.Animation[AnimationNum].LoopTime[x]); } BinaryFile.Save(filename, ref writer); }
/// <summary> /// Метод изменяет анкету текущего пользователя /// </summary> /// <returns></returns> public ActionResult EditProfile() { var profile = jobseekerRepository.FindProfile(Convert.ToInt64(User.Identity.GetUserId())); if (profile != null) { var exp = GetExperienceLists(); foreach (SelectListItem e in exp) { if (profile.Experience.Contains(experienceRepository.Load(Convert.ToInt64(e.Value))) == true) { e.Selected = true; } } BinaryFile file = new BinaryFile(); if (profile.Avatar != null && System.IO.File.Exists(profile.Avatar.Path)) { file.Content = System.IO.File.ReadAllBytes(profile.Avatar.Path); file.ContentType = profile.Avatar.ContentType; file.Name = profile.Avatar.Name; file.Path = profile.Avatar.Path; } var model = new ProfileModel { Entity = profile, Id = profile.Id, Experience = exp, DateOfBirth = profile.DateofBirth, Name = profile.Name, File = file }; return(View(model)); } else { return(RedirectToAction("CreateProfile", "Jobseeker")); } }
/// <summary> /// Saves the binary file contents to the external storage medium associated with the provider. /// </summary> /// <param name="binaryFile">The binary file.</param> /// <exception cref="System.ArgumentException">File Data must not be null.</exception> public override void SaveContent( BinaryFile binaryFile ) { var filePath = GetFilePath( binaryFile ); // Create the directory if it doesn't exist var directoryName = Path.GetDirectoryName( filePath ); if ( !Directory.Exists( directoryName ) ) { Directory.CreateDirectory( directoryName ); } // Write the contents to file using ( var inputStream = binaryFile.ContentStream ) { if ( inputStream != null ) { using ( var outputStream = File.OpenWrite( filePath ) ) { inputStream.CopyTo( outputStream ); } } } }
/// <summary> /// Saves the file to the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> /// <param name="context">The context.</param> /// <exception cref="System.ArgumentException">File Data must not be null.</exception> public override void SaveFile( BinaryFile file, HttpContext context ) { if ( file.Data == null ) { throw new ArgumentException( "File Data must not be null." ); } var url = GenerateUrl( file ); var physicalPath = GetPhysicalPath( url, context ); var directoryName = Path.GetDirectoryName( physicalPath ); if ( !Directory.Exists( directoryName ) ) { Directory.CreateDirectory( directoryName ); } File.WriteAllBytes( physicalPath, file.Data.Content ); // Set Data to null after successful OS save so the the binary data is not // written into the database. file.Data = null; file.Url = url; }
public static void Write8Bit(BinaryFile waveFile, float[][] sound, int sampleCount, int channels) { for (int i = 0; i < sampleCount; i++) { for (int ic = 0; ic < channels; ic++) { int val = SoundIOUtils.RoundToClosestInt((sound[ic][i] + 1) * 128); if (val > 255) { val = 255; } if (val < 0) { val = 0; } byte b = (byte)val; waveFile.Write(b); } } }
/// <summary> /// Handles the Delete event of the gBinaryFile control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param> protected void gBinaryFile_Delete(object sender, RowEventArgs e) { RockTransactionScope.WrapTransaction(() => { BinaryFileService binaryFileService = new BinaryFileService(); BinaryFile binaryFile = binaryFileService.Get((int)e.RowKeyValue); if (binaryFile != null) { string errorMessage; if (!binaryFileService.CanDelete(binaryFile, out errorMessage)) { mdGridWarning.Show(errorMessage, ModalAlertType.Information); return; } binaryFileService.Delete(binaryFile, CurrentPersonId); binaryFileService.Save(binaryFile, CurrentPersonId); } }); BindGrid(); }
/// <summary> /// Saves the file to the external storage medium associated with the provider. /// </summary> /// <param name="file">The file.</param> /// <param name="context">The context.</param> /// <exception cref="System.ArgumentException">File Data must not be null.</exception> public override void SaveFile(BinaryFile file, HttpContext context) { if (file.Data == null) { throw new ArgumentException("File Data must not be null."); } var url = GenerateUrl(file); var physicalPath = GetPhysicalPath(url, context); var directoryName = Path.GetDirectoryName(physicalPath); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } File.WriteAllBytes(physicalPath, file.Data.Content); // Set Data to null after successful OS save so the the binary data is not // written into the database. file.Data = null; file.Url = url; }
/// <summary> /// Parse out the xml string from the passed chunk data byte array /// </summary> /// <param name="chunkDataByteArray"></param> /// <returns>xml string</returns> private static string ParseChunkData(byte[] chunkDataByteArray) { var bf = new BinaryFile(chunkDataByteArray, BinaryFile.ByteOrder.BigEndian, Encoding.ASCII); int val1 = bf.ReadInt32(); int val2 = bf.ReadInt32(); int val3 = bf.ReadInt32(); string val4 = bf.ReadString(4); string val5 = bf.ReadString(4); int chunkSize = bf.ReadInt32(); string val7 = bf.ReadString(4); var xmlChunkBytes = new byte[chunkSize]; xmlChunkBytes = bf.ReadBytes(0, chunkSize, BinaryFile.ByteOrder.LittleEndian); string xmlString = BinaryFile.ByteArrayToString(xmlChunkBytes); int val8 = bf.ReadInt32(BinaryFile.ByteOrder.LittleEndian); return(xmlString); }
static void Test3() { File.Delete(@"z:\te.ed"); var ef = new BinaryFile(@"z:\te.ed"); Stopwatch sw = new Stopwatch(); var writer = ef.GetWriter(); var reader = ef.GetReader(); int w = sizeof(int); int count = 200000; int l = w * count; sw.Start(); writer.Write(1, count); sw.Stop(); Console.WriteLine(sw.ElapsedMilliseconds); var x = new FileInfo(@"z:\te.ed"); ef.Dispose(); Console.WriteLine(x.Length == l); }
/// <summary> /// Handles the Click event of the lbPrepareCertificate control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void lbPrepareCertificate_Click(object sender, EventArgs e) { // // Decode the data in the hidden field into the raw certificate data. // var certData = Rock.Security.Encryption.DecryptString(hfCertificate.Value) .Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries) .Select(v => Convert.FromBase64String(v)) .ToList(); var pkcs12 = AcmeHelper.GetPkcs12Certificate(tbCertificatePassword.Text, certData.First(), certData.Skip(1).ToList()); // // Store the password protected PKCS12 data as a binary file. // var rockContext = new RockContext(); var outputBinaryFile = new BinaryFile { IsTemporary = true, ContentStream = new System.IO.MemoryStream(pkcs12), FileName = "Certfificate.p12", MimeType = "application/x-pkcs12", BinaryFileTypeId = new BinaryFileTypeService(rockContext).Get(Rock.SystemGuid.BinaryFiletype.DEFAULT.AsGuid()).Id }; new BinaryFileService(rockContext).Add(outputBinaryFile); rockContext.SaveChanges(); // // Present a download link to the user. // pnlDownloadCertificate.Visible = false; nbRenewStatus.Text = string.Format("Your <a href='/GetFile.ashx?guid={0}'>certificate</a> is ready for download.", outputBinaryFile.Guid); nbRenewStatus.NotificationBoxType = NotificationBoxType.Success; }
/// <summary> /// Creates the document. /// </summary> /// <param name="mergeTemplate">The merge template.</param> /// <param name="mergeObjectList">The merge object list.</param> /// <param name="globalMergeFields">The global merge fields.</param> /// <returns></returns> public override BinaryFile CreateDocument(MergeTemplate mergeTemplate, List <object> mergeObjectList, Dictionary <string, object> globalMergeFields) { this.Exceptions = new List <Exception>(); BinaryFile outputBinaryFile = null; var rockContext = new RockContext(); var binaryFileService = new BinaryFileService(rockContext); var templateBinaryFile = binaryFileService.Get(mergeTemplate.TemplateBinaryFileId); if (templateBinaryFile == null) { return(null); } string templateHtml = templateBinaryFile.ContentsToString(); var htmlMergeObjects = GetHtmlMergeObjects(mergeObjectList, globalMergeFields); string outputHtml = templateHtml.ResolveMergeFields(htmlMergeObjects); HtmlDocument outputDoc = new HtmlDocument(); outputDoc.LoadHtml(outputHtml); var outputStream = new MemoryStream(); outputDoc.Save(outputStream); outputBinaryFile = new BinaryFile(); outputBinaryFile.IsTemporary = true; outputBinaryFile.ContentStream = outputStream; outputBinaryFile.FileName = "MergeTemplateOutput" + Path.GetExtension(templateBinaryFile.FileName); outputBinaryFile.MimeType = templateBinaryFile.MimeType; outputBinaryFile.BinaryFileTypeId = new BinaryFileTypeService(rockContext).Get(Rock.SystemGuid.BinaryFiletype.DEFAULT.AsGuid()).Id; binaryFileService.Add(outputBinaryFile); rockContext.SaveChanges(); return(outputBinaryFile); }
/// <summary> /// Creates the document. /// </summary> /// <param name="mergeTemplate">The merge template.</param> /// <param name="mergeObjectList">The merge object list.</param> /// <param name="globalMergeFields">The global merge fields.</param> /// <returns></returns> public override BinaryFile CreateDocument( MergeTemplate mergeTemplate, List<object> mergeObjectList, Dictionary<string, object> globalMergeFields ) { this.Exceptions = new List<Exception>(); BinaryFile outputBinaryFile = null; var rockContext = new RockContext(); var binaryFileService = new BinaryFileService( rockContext ); var templateBinaryFile = binaryFileService.Get( mergeTemplate.TemplateBinaryFileId ); if ( templateBinaryFile == null ) { return null; } string templateHtml = templateBinaryFile.ContentsToString(); var htmlMergeObjects = GetHtmlMergeObjects( mergeObjectList, globalMergeFields ); string outputHtml = templateHtml.ResolveMergeFields( htmlMergeObjects ); HtmlDocument outputDoc = new HtmlDocument(); outputDoc.LoadHtml( outputHtml ); var outputStream = new MemoryStream(); outputDoc.Save( outputStream ); outputBinaryFile = new BinaryFile(); outputBinaryFile.IsTemporary = true; outputBinaryFile.ContentStream = outputStream; outputBinaryFile.FileName = "MergeTemplateOutput" + Path.GetExtension( templateBinaryFile.FileName ); outputBinaryFile.MimeType = templateBinaryFile.MimeType; outputBinaryFile.BinaryFileTypeId = new BinaryFileTypeService( rockContext ).Get( Rock.SystemGuid.BinaryFiletype.DEFAULT.AsGuid() ).Id; binaryFileService.Add( outputBinaryFile ); rockContext.SaveChanges(); return outputBinaryFile; }
/// <summary> /// Ends the get. /// </summary> /// <param name="asyncResult">The asynchronous result.</param> /// <param name="context">The context.</param> /// <returns></returns> public BinaryFile EndGet( IAsyncResult asyncResult, HttpContext context ) { // restore the command from the context SqlCommand cmd = (SqlCommand)context.Items["cmd"]; using ( SqlDataReader reader = cmd.EndExecuteReader( asyncResult ) ) { BinaryFile binaryFile = new BinaryFile(); // Columns must be read in Sequential Order (see stored procedure spBinaryFileGet) reader.Read(); binaryFile.Id = reader["Id"] as int? ?? 0; binaryFile.IsTemporary = ( reader["IsTemporary"] as int? ) == 1; binaryFile.IsSystem = ( reader["IsSystem"] as int? ) == 1; binaryFile.BinaryFileTypeId = reader["BinaryFileTypeId"] as int?; binaryFile.Url = reader["Url"] as string; binaryFile.FileName = reader["FileName"] as string; binaryFile.MimeType = reader["MimeType"] as string; binaryFile.LastModifiedDateTime = reader["LastModifiedDateTime"] as DateTime?; binaryFile.Description = reader["Description"] as string; int? storageEntityTypeId = reader["StorageEntityTypeId"] as int?; binaryFile.SetStorageEntityTypeId( storageEntityTypeId ); var guid = reader["Guid"]; if ( guid is Guid ) { binaryFile.Guid = (Guid)guid; } string entityTypeName = reader["StorageEntityTypeName"] as string; binaryFile.Data = new BinaryFileData(); // read the fileContent from the database just in case it's stored in the database, otherwise, the Provider will get it var content = reader["Content"]; if ( content != null ) { binaryFile.Data.Content = content as byte[]; } Rock.Storage.ProviderComponent provider = Rock.Storage.ProviderContainer.GetComponent( entityTypeName ); binaryFile.Data.Content = provider.GetFileContent( binaryFile, context ); return binaryFile; } }
/// <summary> /// Determines the storage provider that was used the last time the file was saved /// </summary> /// <param name="item">The item.</param> /// <returns></returns> private Storage.ProviderComponent DetermineBinaryFileStorageProvider( BinaryFile item ) { Rock.Storage.ProviderComponent storageProvider = null; if ( item != null ) { item.StorageEntityType = item.StorageEntityType ?? new EntityTypeService( this.RockContext ).Get( item.StorageEntityTypeId ?? 0 ); if ( item.StorageEntityType != null ) { storageProvider = Rock.Storage.ProviderContainer.GetComponent( item.StorageEntityType.Name ); } } return storageProvider; }
/// <summary> /// Deletes the specified item. /// </summary> /// <param name="item">The item.</param> /// <param name="personId">The person identifier.</param> /// <returns></returns> public override bool Delete( BinaryFile item, int? personId ) { // if we can determine the StorageProvider, use the provider to remove the file from the provider's external storage medium Rock.Storage.ProviderComponent storageProvider = DetermineBinaryFileStorageProvider( item ); if ( storageProvider != null ) { storageProvider.RemoveFile( item, HttpContext.Current ); } // delete the record from the database return base.Delete( item, personId ); }
/// <summary> /// Saves an ExcelPackage as a BinaryFile and stores it in the database /// </summary> /// <param name="excel">The ExcelPackage object to save</param> /// <param name="fileName">The filename to save the workbook as</param> /// <param name="rockContext">The RockContext to use</param> /// <param name="binaryFileType">Optionally specifies the BinaryFileType to apply to this file for security purposes</param> /// <returns></returns> public static BinaryFile Save( ExcelPackage excel, string fileName, RockContext rockContext, BinaryFileType binaryFileType = null ) { if ( binaryFileType == null ) { binaryFileType = new BinaryFileTypeService( rockContext ).Get( Rock.SystemGuid.BinaryFiletype.DEFAULT.AsGuid() ); } var ms = excel.ToMemoryStream(); var binaryFile = new BinaryFile() { Guid = Guid.NewGuid(), IsTemporary = true, BinaryFileTypeId = binaryFileType.Id, MimeType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", FileName = fileName, ContentStream = ms }; var binaryFileService = new BinaryFileService( rockContext ); binaryFileService.Add( binaryFile ); rockContext.SaveChanges(); return binaryFile; }