public void ReadWebFile(SmartStream stream, string webPath)
{
using (WebFile web = WebFile.Read(stream, webPath))
{
AddWebFile(web);
}
}
protected void Download1_Click(object sender, EventArgs e)
{
string[] additionalFiles = new string[2] {
"files/16.png", "files/17.png"
};
WebFile.Download("files/15.png", "Images", 1, additionalFiles);
}
public void LoadWebFile(string filePath)
{
using (WebFile web = new WebFile(this, filePath, OnRequestDependency))
{
web.Load(filePath);
}
}
public async Task <ActionResult> Details(long id, string extra = null, int v = 0)
{
WebFile webFile = await WebFile.GetAvailableFiles(db, User, UserManager, RoleManager).FindAsync(id);
if (webFile == null)
{
return(HttpNotFound());
}
string location = webFile.Location;
if (extra == "preview")
{
if (!string.IsNullOrEmpty(webFile.PreviewLocation))
{
location = webFile.PreviewLocation;
}
extra = null;
}
string filepath = location.IsRootedPath() ? location : Server.MapPath(location);
string contentType = FTT.GetMimeType(location ?? "");
if (contentType == "")
{
contentType = "application/octet-stream";
}
if (extra == null)
{
string inline = (v == 1) ? "inline" : "attachment";
string filename = webFile.Name.Replace(" ", "-") + Path.GetExtension(location);
Response.Headers["Content-Disposition"] = inline + ";filename=" + filename;
}
var fileToDownload = ReconcileFileToDownload(extra, filepath);
if (Request.Headers.AllKeys.Contains("Range"))
{
var range = Request.Headers["Range"];
if (!string.IsNullOrEmpty(range))
{
var replace = new Regex(@"[^\d]");
var byte_range = replace.Replace(range, " ").Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (byte_range.Length == 2)
{
var start = long.Parse(byte_range[0]);
var end = long.Parse(byte_range[1]);
using (var stream = System.IO.File.OpenRead(fileToDownload))
{
stream.Seek(start, SeekOrigin.Begin);
var bytes = new byte[end - start];
stream.Read(bytes, 0, bytes.Length);
Response.StatusCode = 206;
Response.StatusDescription = "Partial Content";
Response.Headers["Content-Range"] = $"bytes {start}-{end}/{stream.Length}";
return(File(bytes, contentType));
}
}
}
}
return(File(System.IO.File.OpenRead(fileToDownload), contentType));
}
internal void ReadWebFile(Stream stream, string filePath, Action <string> requestDependencyCallback)
{
using (WebFile web = new WebFile(this, filePath, requestDependencyCallback))
{
web.Read(stream);
}
}
public async Task <ActionResult> DeleteConfirmed(long id)
{
WebFile webFile = await WebFile.GetAvailableFiles(db, User, UserManager, RoleManager, !User.IsInRole(Roles.Administrators))
.Include(f => f.Permissions).FindAsync(id);
if (webFile == null)
{
return(HttpNotFound());
}
var folders = db.ActiveSharedFolders
.Where(f => f.Files.Select(w => w.Id).Contains(webFile.Id))
.Include(f => f.Files)
.ToList();
foreach (var folder in folders)
{
folder.Files.Remove(webFile);
}
db.SaveChanges();
db.Permissions.RemoveRange(webFile.Permissions);
db.WebFiles.Remove(webFile);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public void PutFileByPath(string path, WebFile file_in)
{
string[] elements = path.Split(WebFileSystem.PathSeparators, StringSplitOptions.RemoveEmptyEntries);
foreach (string element in elements)
{
Trace.TraceInformation("Requested file: " + element);
}
WebDirectory basedir = this.GetDirectoryByPath(
this._root, new ArraySegment <string>(elements, 0, elements.Length - 1).Array);
if (null == basedir)
{
basedir = this._root;
}
string filename = elements[elements.Length - 1];
WebFile outfile = basedir.GetFile(filename);
if (null != outfile)
{
Trace.TraceError("Attempted to put existing file: " + path);
}
else
{
basedir.PutFile(filename, file_in);
}
}
void btnUpdateAvartar_Click(object sender, System.Web.UI.ImageClickEventArgs e)
{
// this is fired when the avatar upload dialog is closed
// we don't really know for sure if the image was updated
// but if it was we should rename it since the previous version may be cached by web browsers
// so we'll check if the files was modified recently, and if so rename it
if ((siteUser != null) && siteUser.AvatarUrl.Length > 0)
{
FileSystemProvider p = FileSystemManager.Providers[WebConfigSettings.FileSystemProvider];
if (p != null)
{
IFileSystem fileSystem = p.GetFileSystem();
string avatarBasePath = "~/Data/Sites/" + siteSettings.SiteId.ToInvariantString() + "/useravatars/";
WebFile avatarFile = fileSystem.RetrieveFile(avatarBasePath + siteUser.AvatarUrl);
if (avatarFile != null)
{
if (avatarFile.Modified > DateTime.Today)
{
// it was updated today so we'll assume it was just now since the avatar dialog just closed
string newfileName = "user"
+ siteUser.UserId.ToInvariantString()
+ "-" + siteUser.Name.ToCleanFileName()
+ "-" + DateTime.UtcNow.Millisecond.ToInvariantString()
+ System.IO.Path.GetExtension(siteUser.AvatarUrl);
fileSystem.MoveFile(avatarBasePath + siteUser.AvatarUrl, avatarBasePath + newfileName, true);
siteUser.AvatarUrl = newfileName;
siteUser.Save();
}
}
}
}
WebUtils.SetupRedirect(this, Request.RawUrl);
}
public void AddSubDirectory(string path, WebFile fileInfo)
{
string pathToNewDirectory = Path.Combine(path, fileInfo.Name);
string pathToNewNonCopyDirectory = pathToNewDirectory;
int copyNumber = 0;
bool copyFound = false;
while (Directory.Exists(pathToNewNonCopyDirectory))
{
copyNumber++;
pathToNewNonCopyDirectory = pathToNewDirectory + "(" + copyNumber + ")";
copyFound = true;
}
if (copyFound)
{
fileInfo.Name += "(" + copyNumber + ")";
}
fileInfo.Path = path;
fileInfo.DateCreation = DateTime.Today;
fileInfo.Comment = "";
fileInfo.Extension = "";
Directory.CreateDirectory(pathToNewNonCopyDirectory);
_context.Files.Add(fileInfo);
_context.SaveChanges();
}
private void btnSave_Click(object sender, EventArgs e)
{
admin.Library.Version = SessionVersion;
//admin.Library.configuration = Configuration.Data;
Library.write_local(admin.Library, Configuration.LibraryFileName);
string WebFile = cbxWebFile.Text;
BackgroundWorker worker = new BackgroundWorker()
{
WorkerReportsProgress = true
};
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
try
{
WebFile wf = admin.Library.configuration.WebFile_List.Single(w => w.Name.Equals(WebFile));
ftp.Upload(Configuration.LibraryFileName, wf.URL, wf.Credentials.UserName, Tools.DecodeStringFromBase64(wf.Credentials.Password));
args.Result = "Archivo subido";
}
catch (Exception ex)
{
args.Result = ex.Message;
}
};
worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
{
MessageBox.Show(args.Result.ToString(), "Guardar y subir", MessageBoxButtons.OK, MessageBoxIcon.Information);
};
worker.RunWorkerAsync();
}
public UpdateDownloadForm(Release release)
{
InitializeComponent();
Icon = Icon.FromHandle(Resources.Update.GetHicon());
Text = release.Name;
Focus();
changeLog.SetChangelog(release.Changelog);
downloadProgress.DisplayStyle = TextProgressBar.ProgressBarDisplayText.Both;
downloadProgress.CustomText = release.Asset.name;
_releaseFile = new WebFile(new Uri(release.Asset.browser_download_url));
_releaseFile.DownloadProgressChanged +=
(sender, args) =>
{
downloadProgress.Invoke(new Action(() => { downloadProgress.Value = args.ProgressPercentage; }));
};
_releaseFile.DownloadFailed += (sender, @event) =>
{
AppLogger.Log.Error("Couldn't download the Release ", @event.Exception);
MessageBox.Show(@event.Exception.Message, UpdateFormStrings.downloadFailed, MessageBoxButtons.OK, MessageBoxIcon.Error);
};
_releaseFile.Downloaded += (sender, args) =>
{
installButton.Invoke(new Action(() =>
{
installButton.Enabled = true;
downloadProgress.Enabled = false;
}));
};
_releaseFile.DownloadFile();
}
void btnUpdateAvartar_Click(object sender, System.Web.UI.ImageClickEventArgs e)
{
if ((siteUser != null) && siteUser.AvatarUrl.Length > 0)
{
FileSystemProvider p = FileSystemManager.Providers[WebConfigSettings.FileSystemProvider];
if (p != null)
{
IFileSystem fileSystem = p.GetFileSystem();
string avatarBasePath = "~/Data/Sites/" + siteSettings.SiteId.ToInvariantString() + "/useravatars/";
WebFile avatarFile = fileSystem.RetrieveFile(avatarBasePath + siteUser.AvatarUrl);
if (avatarFile != null)
{
if (avatarFile.Modified > DateTime.Today)
{
string newfileName = "user"
+ siteUser.UserId.ToInvariantString()
+ "-" + siteUser.Name.ToCleanFileName()
+ "-" + DateTime.UtcNow.Millisecond.ToInvariantString()
+ System.IO.Path.GetExtension(siteUser.AvatarUrl);
fileSystem.MoveFile(avatarBasePath + siteUser.AvatarUrl, avatarBasePath + newfileName, true);
siteUser.AvatarUrl = newfileName;
siteUser.Save();
}
}
}
}
WebUtils.SetupRedirect(this, Request.RawUrl);
}
/// <summary>
/// Helper method for loading the portal items
/// </summary>
/// <param name="bw"></param>
private void LoadPortalItems(BackgroundWorker bw, bool isLegacyPortal)
{
portalItems = new List <EditablePortalItem>();
bw.ReportProgress(0, "Loading Web pages...");
portalItems.AddRange(WebPage.GetItems(Service));
bw.ReportProgress(0, "Loading Entity forms...");
portalItems.AddRange(EntityForm.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Entity lists...");
portalItems.AddRange(EntityList.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Web templates...");
portalItems.AddRange(WebTemplate.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Web files...");
portalItems.AddRange(WebFile.GetItems(Service));
bw.ReportProgress(0, "Loading Web form steps...");
portalItems.AddRange(WebFormStep.GetItems(Service));
bw.ReportProgress(0, "Loading Content Snippets...");
portalItems.AddRange(ContentSnippet.GetItems(Service, ref isLegacyPortal));
if (!isLegacyPortal)
{
bw.ReportProgress(0, "Loading Portal languages...");
ctvf.Languages = Service.RetrieveMultiple(new QueryExpression("adx_websitelanguage")
{
ColumnSet = new ColumnSet(true)
}).Entities.ToList();
}
}
private void AddWebFile(WebFile web)
{
foreach (ResourcesFile resource in web.ResourceFiles)
{
m_resources.Add(resource);
}
}
/// <summary>
/// Loads the WriteableBitmap from the source URI of the given BitmapImage
/// </summary>
/// <param name="target">The target WriteableBitmap.</param>
/// <param name="source">The source BitmapImage.</param>
/// <returns></returns>
public static async Task <WriteableBitmap> LoadFromBitmapImageSourceAsync(this WriteableBitmap target, BitmapImage source)
{
if (source.UriSource == null ||
source.UriSource.OriginalString == null)
{
return(target);
}
string originalString = source.UriSource.OriginalString;
if (originalString.StartsWith("ms-appx:/"))
{
string installedFolderImageSourceUri = originalString.Replace("ms-appx:/", "").TrimStart('/');
await target.LoadAsync(installedFolderImageSourceUri);
}
else
{
var file = await WebFile.SaveAsync(source.UriSource, ApplicationData.Current.TemporaryFolder);
await target.LoadAsync(file);
await file.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
return(target);
}
public void LoadWebFile(string webPath)
{
using (WebFile web = WebFile.Load(webPath))
{
AddWebFile(web);
}
}
public int UpdateWebFile(WebFile webFile)
{
using (AIYunNetContext context = new AIYunNetContext())
{
WebFile originalFile = context.WebFile.Find(webFile.FileID);
if (originalFile != null)
{
originalFile.ClassID = webFile.ClassID;
originalFile.ClassName = webFile.ClassName;
originalFile.Click = webFile.Click;
originalFile.CompanyId = webFile.CompanyId;
originalFile.Description = webFile.Description;
originalFile.FileName = webFile.FileName;
originalFile.FileType = webFile.FileType;
originalFile.InTime = webFile.InTime;
originalFile.InUser = webFile.InUser;
originalFile.Remark = webFile.Remark;
originalFile.Sequence = webFile.Sequence;
originalFile.Tags = webFile.Tags;
originalFile.Title = webFile.Title;
originalFile.Editon = DateTime.Now;
context.SaveChanges();
return(1);
}
else
{
return(0);
}
}
}
public void ReadWebFile(Stream stream, string filePath)
{
using (WebFile web = new WebFile())
{
web.Read(stream);
ProcessWebFileData(web.FileData, filePath);
}
}
public Command <UploadCommandResult> With(string name, string description, HttpPostedFileBase httpFile)
{
Name = name;
Description = description;
WebFile = new WebFile(httpFile);
return(this);
}
public void PutFile(string filename, WebFile file)
{
if (filename.StartsWith("/"))
{
filename = filename.Substring(1);
}
this.files[filename] = file;
}
public void LoadWebFile(string filePath)
{
using (WebFile web = new WebFile())
{
web.Load(filePath);
ProcessWebFileData(web.FileData, filePath);
}
}
public object GetDataByLinkId(string linkId)
{
WebFile fileInfo = this.GetFile(linkId);
string fullPathToFile = Path.Combine(fileInfo.Path, fileInfo.Name);
return(new { fileBytes = File.ReadAllBytes(fullPathToFile), fileName = fileInfo.Name });
}
public void ReadWebFile(Stream stream, string filePath)
{
using (WebFile web = new WebFile(this, filePath, OnRequestDependency))
{
web.Read(stream);
AddWebFile(web);
}
}
internal MediaStream(MediaStreamManager manager, WebFile file, int id, bool linger)
{
this.id = id;
this.file = file;
this.manager = manager;
this.currentReadOperationWaitHandle = new AutoResetEvent(false);
manager.NewDataAvailable += manager_NewDataAvailable;
this.linger = linger;
}
public int AddWebFile(WebFile webFile)
{
using (AIYunNetContext context = new AIYunNetContext())
{
context.WebFile.Add(webFile);
context.SaveChanges();
return(1);
}
}
private AssetStorageMetadata StoreAsset()
{
var fileBytes = WebFile.ReadBytes();
var fileName = $"original{WebFile.Extension}";
var storageMetadata = _imageFileRepository.StoreAsset(Id, fileName, WebFile.ContentType, fileBytes);
return(storageMetadata);
}
private void LoadItems()
{
ctv.Enabled = false;
WorkAsync(new WorkAsyncInfo
{
Message = "Loading portal items...",
Work = (bw, e) =>
{
portalItems = new List <EditablePortalItem>();
bw.ReportProgress(0, "Loading Web pages...");
portalItems.AddRange(WebPage.GetItems(Service));
bw.ReportProgress(0, "Loading Entity forms...");
portalItems.AddRange(EntityForm.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Entity lists...");
portalItems.AddRange(EntityList.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Web templates...");
portalItems.AddRange(WebTemplate.GetItems(Service, ref isLegacyPortal));
bw.ReportProgress(0, "Loading Web files...");
portalItems.AddRange(WebFile.GetItems(Service));
bw.ReportProgress(0, "Loading Web form steps...");
portalItems.AddRange(WebFormStep.GetItems(Service));
bw.ReportProgress(0, "Loading Content Snippets...");
portalItems.AddRange(ContentSnippet.GetItems(Service, ref isLegacyPortal));
portalItems.SelectMany(p => p.Items).ToList().ForEach(i => i.StateChanged += CodeItem_StateChanged);
},
ProgressChanged = e =>
{
SetWorkingMessage(e.UserState.ToString());
},
PostWorkCallBack = e =>
{
if (e.Error != null)
{
if (((FaultException <OrganizationServiceFault>)e.Error).Detail.ErrorCode == -2147217149)
{
MessageBox.Show(e.Error.ToString());
var message =
"Unable to load code items: Please ensure you are targeting an organization linked to a Microsoft Portal (not a legacy Adxstudio one)";
MessageBox.Show(this, message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
LogError(message);
}
else
{
MessageBox.Show(this, $"An error occured while loading code items: {e.Error.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
LogError($"An error occured while loading code items: {e.Error.ToString()}");
}
}
ctv.DisplayCodeItems(portalItems, isLegacyPortal);
ctv.Enabled = true;
}
});
}
/// <summary>
/// Show details/info for a WebFile
/// </summary>
/// <param name="File">WebFile object</param>
/// <param name="createNewInstance">Whether to create a new instance</param>
public void ShowFileDetails(WebFile File, DataGridView parentDataGrid, bool isLocal = false, bool createNewInstance = true)
{
Program.log.Info("Showing file details dialog : " + File.URL);
if (createNewInstance)
{
FrmFileDetails = new FileDetailsWindow();
}
FrmFileDetails.IsLocalFile = isLocal;
FrmFileDetails.ParentDataGrid = parentDataGrid;
FrmFileDetails.CurrentFile = File;
FrmFileDetails.LabelFileName.Text = File.Name;
FrmFileDetails.LabelValueName.Text = File.Name;
FrmFileDetails.LabelValueRefferer.Text = File.Host;
FrmFileDetails.LabelValueType.Text = File.Type;
FrmFileDetails.InfoFileURL.Text = Uri.UnescapeDataString(File.URL);
// Builds parts of the URL into a better presented string, simply replaces '/' with '>' and no filename
var url = new Uri(File.URL);
var directories = new StringBuilder();
if (!File.URL.StartsWith(@"C:\"))
{
directories.Append(File.Host);
}
else
{
FrmFileDetails.LabelValueRefferer.Text = "Local";
} // Appends the Host at the start if not Local, else it will be named 'Local'
foreach (string path in url.LocalPath.Split('/', '\\'))
{
if (!Path.HasExtension(path))
{
directories.Append(path + "> ");
}
}
FrmFileDetails.LabelValueDirectory.Text = directories.ToString();
FrmFileDetails.LabelValueSize.Text = StringExtensions.BytesToPrefix(File.Size);
FrmFileDetails.LabelValueAge.Text = StringExtensions.TimeSpanAge(File.DateUploaded);
if (!createNewInstance)
{
FrmFileDetails.CheckFileEvents();
}
else
{
FrmFileDetails.ShowDialog(this);
}
Program.log.Info("Successfully loaded file details dialog");
}
private async void InitializeTest()
{
var imageUri = new Uri("https://dl.dropbox.com/u/1192076/IMG_8839.JPG");
var fullSizeBitmap = new BitmapImage(imageUri);
originalImage.Source = fullSizeBitmap;
var file = await WebFile.SaveAsync(imageUri);
resizedImage.Source = await new WriteableBitmap(1, 1).LoadAsync(file, 160, 120);
}
private void lblVersion_Click(object sender, EventArgs e)
{
try
{
WebFile wf = (WebFile)cbxWebFile.SelectedItem;
Library lib = new Library(wf.URL, wf.Credentials.UserName, Tools.DecodeStringFromBase64(wf.Credentials.Password));
MessageBox.Show("Versión en línea: " + lib.Version, "Versión", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch
{
}
}
public ResponseModel<WebFile> UploadFile(HttpPostedFileBase file, string md5)
{
file.SaveAs(ConstData.UploadFilePath + file.FileName);
Uri uri = HttpContext.Current.Request.Url;
WebFile webFile = new WebFile()
{
Scheme = uri.Scheme,
Host = uri.Host,
Port = uri.Port,
LocalPath = uri.LocalPath,
FileName = file.FileName,
FileSize = Math.Round(file.InputStream.Length / 1024 / 1024.0, 2) + "M",
MD5 = md5,
LogDate = DateTime.Now
};
webFile.Id = webFile.Insert();
return new ResponseModel<WebFile>() { code = ErrorCode.General.success, result = webFile };
}
