public async Task <System.Web.Http.IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new System.Web.Http.HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var accountName = ConfigurationManager.AppSettings["storage:account:name"];
var accountKey = ConfigurationManager.AppSettings["storage:account:key"];
var storageAccount = new CloudStorageAccount(new StorageCredentials(accountName, accountKey), true);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer imagesContainer = blobClient.GetContainerReference(Container);
var provider = new AzureStorageMultipartFormDataStreamProvider(imagesContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
return(Ok($"File: {filename} has successfully uploaded"));
}
public async Task <System.Web.Http.IHttpActionResult> AzureUpload()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new System.Web.Http.HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
CloudBlobContainer blobContainer = AzureContainer();
var provider = new AzureStorageMultipartFormDataStreamProvider(blobContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
return(Ok($"File: {filename} has successfully uploaded"));
}
public async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
CloudBlobContainer appContainer = ServerUtils.GetCloudBlobContainer();
var provider = new AzureStorageMultipartFormDataStreamProvider(appContainer, "uploads/" + User.Identity.GetUserId());
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
await MakeLog(new Dictionary <string, string>() { { "file", filename } });
return(Ok(filename));
}
public async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var accountName = ConfigurationManager.AppSettings["storage:account:name"];
var accountKey = ConfigurationManager.AppSettings["storage:account:key"];
var storageAccount = new CloudStorageAccount(new StorageCredentials(accountName, accountKey), true);
var blobClient = storageAccount.CreateCloudBlobClient();
var imagesContainer = blobClient.GetContainerReference(Container);
var provider = new AzureStorageMultipartFormDataStreamProvider(imagesContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
var currentUser = User.Identity.Name;
var userinfo = await _userManager.FindByNameAsync(currentUser);
if (userinfo.Image != null && !userinfo.Image.Contains("default"))
{
CloudBlockBlob blockBlob = imagesContainer.GetBlockBlobReference(userinfo.Image.Remove(0, 54));
blockBlob.Delete();
}
var identityUser = new IdentityUser
{
Id = userinfo.Id,
UserName = userinfo.UserName,
Email = userinfo.Email,
Name = userinfo.Name,
Company = userinfo.Company,
PasswordHash = userinfo.PasswordHash,
SecurityStamp = userinfo.SecurityStamp,
Roles = userinfo.Roles,
Image = storageAccount.BlobEndpoint + Container + "/" + filename,
};
var result = await _userManager.UpdateAsync(identityUser);
return(Ok(identityUser));
}
public async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var accountName = ConfigurationManager.AppSettings["storage:account:name"];
var accountKey = ConfigurationManager.AppSettings["storage:account:key"];
var storageAccount = new CloudStorageAccount(new StorageCredentials(accountName, accountKey), true);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer filesContainer = blobClient.GetContainerReference(Container);
var provider = new AzureStorageMultipartFormDataStreamProvider(filesContainer);
if (await filesContainer.CreateIfNotExistsAsync())
{
await filesContainer.SetPermissionsAsync(new
BlobContainerPermissions
{
PublicAccess =
BlobContainerPublicAccessType.Blob
});
}
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
var uploadedFileName = provider.Contents.FirstOrDefault()?.Headers.ContentDisposition.FileName.Replace("\"", string.Empty);
var fileLog = new FileUploadLogItem()
{
Location = Request.RequestUri.AbsoluteUri,
Size = Request.Content.Headers.ContentLength.HasValue ? Request.Content.Headers.ContentLength.Value : 0,
FileExtension = Path.GetExtension(uploadedFileName),
ContentType = provider.FileData.FirstOrDefault()?.Headers.ContentType.ToString(),
AzureFilePath = provider.UploadedPath,
Name = filename,
TimeStamp = DateTime.UtcNow
};
new TableManager(storageAccount).InsertEntity(fileLog);
return(Ok($"File: {filename} has successfully uploaded"));
}
public async Task <IHttpActionResult> PostFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var accountName = ConfigurationManager.AppSettings["storage:account:name"];
var accountKey = ConfigurationManager.AppSettings["storage:account:key"];
var storageAccount = new CloudStorageAccount(new StorageCredentials(accountName, accountKey), true);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer temps = blobClient.GetContainerReference("temps");
CloudBlobContainer files = blobClient.GetContainerReference("files");
var provider = new AzureStorageMultipartFormDataStreamProvider(temps);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
string path = provider.Contents.FirstOrDefault().Headers.ContentDisposition.Name.Replace("\"", "");
ICollection <FolderFile> folderFiles = new List <FolderFile>();
foreach (var fileData in provider.FileData)
{
CloudBlockBlob srcBlob = temps.GetBlockBlobReference(fileData.LocalFileName);
CloudBlockBlob destBlob = files.GetBlockBlobReference(path + "/" + fileData.LocalFileName);
await destBlob.StartCopyAsync(srcBlob);
srcBlob.Delete();
FolderFile newFolderFile = new FolderFile
{
StartDate = DateTime.Now,
FolderId = null,
Target = new Entities.File
{
Id = new Guid(fileData.LocalFileName),
Path = path + "/" + fileData.LocalFileName,
Value = fileData.Headers.ContentDisposition.FileName.Replace("\"", "")
}
};
db.FolderFiles.Add(newFolderFile);
await db.SaveChangesAsync();
folderFiles.Add(newFolderFile);
}
return(Ok(new FileSave
{
Photos = folderFiles
}));
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
}
public async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var provider = new AzureStorageMultipartFormDataStreamProvider(BlobHelper.GetWebApiContainer());
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
string originalFileName = provider.Contents[0].Headers.ContentDisposition.FileName;
//Capture File details and store in SQL Database "BlobFiles"
SqlCommand cmd;
SqlConnection con;
CloudBlockBlob blob = BlobHelper.GetWebApiContainer().GetBlockBlobReference(originalFileName);
con = new SqlConnection(@"Data Source = (localdb)\MSSQLLocalDB; Initial Catalog = BlobFiles; Integrated Security = True; Connect Timeout = 30; Encrypt = False; TrustServerCertificate = False; ApplicationIntent = ReadWrite; MultiSubnetFailover = False");
con.Open();
blob.FetchAttributes();
string extension = Path.GetExtension(blob.Uri.AbsolutePath);
cmd = new SqlCommand("INSERT INTO Files (Name,Size,ContentType,Extension,Location,Timestamp,FilePath) VALUES (@Name,@Size,@ContentType,@Extension,@Location,@Timestamp,@FilePath)", con);
cmd.Parameters.AddWithValue("@Name", blob.Name);
cmd.Parameters.AddWithValue("@Size", ((blob.Properties.Length) / 1000) + "kb");
cmd.Parameters.AddWithValue("@ContentType", blob.Properties.ContentType);
cmd.Parameters.AddWithValue("@Extension", extension.Substring(0, extension.Length - 3));
cmd.Parameters.AddWithValue("@Location", blob.Uri.AbsoluteUri);
cmd.Parameters.AddWithValue("@Timestamp", DateTime.Now.ToString());
cmd.Parameters.AddWithValue("@FilePath", blob.Uri.AbsolutePath);
cmd.ExecuteNonQuery();
if (string.IsNullOrEmpty(originalFileName))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
return(Ok($"File: {originalFileName} has successfully uploaded"));
}
public async Task <IHttpActionResult> Upload(string username)
{
if (!Request.Content.IsMimeMultipartContent())
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
CloudStorageAccount cloudStorageAccount = ConnectionString.GetConnectionString();
CloudBlobClient cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();;
CloudBlobContainer imagesContainer = cloudBlobClient.GetContainerReference(Container);
if (await imagesContainer.CreateIfNotExistsAsync())
{
await imagesContainer.SetPermissionsAsync(
new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Blob
});
}
var provider = new AzureStorageMultipartFormDataStreamProvider(imagesContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Details: {ex.Message}"));
}
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured while uploading your file. Please try again."));
}
var user = await _userManager.FindByNameAsync(username);
user.Photo = imagesContainer.GetBlockBlobReference(filename).Uri.ToString();
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
BadRequest(ModelState);
}
return(Ok(user.Photo));
}
public async Task <Response <string> > UploadImageToAzure(HttpContent request)
{
try
{
string[] _supportedMimeTypes = { "image/png", "image/jpeg", "image/jpg" };
var httprequest = HttpContext.Current.Request;
if (!request.IsMimeMultipartContent("form-data"))
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.UnsupportedMediaType
});
}
GetStorageReference();
var provider = new AzureStorageMultipartFormDataStreamProvider(blobContainer);
try
{
await request.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.BadRequest, Message = $"An error has occured.Details: { ex.Message}"
});
}
var storagePath = ConfigurationManager.AppSettings["storagePath"];
// Retrieve the filename of the file you have uploaded
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
var filePath = string.Concat(storagePath, filename);
if (string.IsNullOrEmpty(filename))
{
return(new Response <string>()
{
StatusCode = System.Net.HttpStatusCode.BadRequest, Message = "An error has occured while uploading your file. Please try again."
});
}
return(new Response <string>()
{
StatusCode = HttpStatusCode.OK, Message = $"{filePath}"
});
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IHttpActionResult> UploadPicture()
{
//1. Define mekanisme azure storage
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
var accountName = ConfigurationManager.AppSettings["storage:account:name"];
var accountKey = ConfigurationManager.AppSettings["storage:account:key"];
var storageAccount = new CloudStorageAccount(new StorageCredentials(accountName, accountKey), true);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer imagesContainer = blobClient.GetContainerReference(Container);
var provider = new AzureStorageMultipartFormDataStreamProvider(imagesContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured: {ex.Message}"));
}
//2. Define File name
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured. Please try again."));
}
//3. Method find user by Auth Token
AuthRepository repo = new AuthRepository();
ClaimsPrincipal principal = Request.GetRequestContext().Principal as ClaimsPrincipal;
var username = principal.Claims.Where(e => e.Type == "sub").FirstOrDefault();
var profile = await repo.FindUser(username.Value);
if (profile == null)
{
return(NotFound());
}
//Set Account Picture to Uri
profile.AccountPicture = provider._blobContainer.Uri.AbsoluteUri + "/" + filename;
var update = await repo.EditMe(profile);
return(Ok(update));
}
public async Task <string> Upload(HttpContent ctnt, string templateName)
{
string filename = "";
var provider = new AzureStorageMultipartFormDataStreamProvider(_TemplateContainer);
await ctnt.ReadAsMultipartAsync(provider);
// Retrieve the filename of the file you have uploaded
filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return("error");
}
return(filename);
}
public async Task <IHttpActionResult> UploadFile()
{
if (!Request.Content.IsMimeMultipartContent("form-data"))
{
throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType);
}
/* TODO: It is advisable to use a Web.config */
var credentials = new
{
accountName = "xxx",
accountKey = "xxx"
};
var storageAccount = new CloudStorageAccount(
new StorageCredentials(credentials.accountName, credentials.accountKey), true
);
var blobClient = storageAccount.CreateCloudBlobClient();
var imagesContainer = blobClient.GetContainerReference(Container);
var provider = new AzureStorageMultipartFormDataStreamProvider(imagesContainer);
try
{
await Request.Content.ReadAsMultipartAsync(provider);
}
catch (Exception ex)
{
return(BadRequest($"An error has occured. Error: {ex.Message}"));
}
var filename = provider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(BadRequest("An error has occured!"));
}
return(Ok(new { url = provider.GetURL() }));
}
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
CloudStorageAccount storageAccount = CloudStorageAccount.Parse("CONNECTION STRING");
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("quickstartblobscb838932-2910-475b-a353-982d28c64a94");
if (req.Method == HttpMethod.Get)
{
string response = "<ul>";
foreach (IListBlobItem item in container.ListBlobs(null, false))
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
response += string.Format("<li>Block blob of length {0}: <a href=\"{1}\">{2}</a></li>\n", blob.Properties.Length, blob.Uri, blob.Name);
}
else if (item.GetType() == typeof(CloudPageBlob))
{
CloudPageBlob pageBlob = (CloudPageBlob)item;
response += string.Format("<li>Page blob of length {0}: <a href=\"{1}\">{2}</a></li>\n", pageBlob.Properties.Length, pageBlob.Uri, pageBlob.Name);
}
else if (item.GetType() == typeof(CloudBlobDirectory))
{
CloudBlobDirectory directory = (CloudBlobDirectory)item;
response += string.Format("<li>Directory: {0}</li>\n", directory.Uri);
}
}
response += @"</ul>
<form method=""post"" enctype=""multipart/form-data"">
<input type=""file"" name=""fileToUpload"" id=""fileToUpload"">
<input type = ""submit"" value = ""Upload Image"" name = ""submit"" >
</form>";
var r = req.CreateResponse(HttpStatusCode.OK, response, "text/plain");
r.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("text/html");
return(r);
}
if (req.Method == HttpMethod.Post)
{
if (req.Content.IsMimeMultipartContent())
{
var streamProvider = new AzureStorageMultipartFormDataStreamProvider(container);
var task = req.Content.ReadAsMultipartAsync(streamProvider);
var filename = streamProvider.FileData.FirstOrDefault()?.LocalFileName;
if (string.IsNullOrEmpty(filename))
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "An error has occured while uploading your file. Please try again."));
}
return(req.CreateResponse(HttpStatusCode.OK, $"File: {filename} has successfully uploaded"));
}
return(req.CreateResponse(HttpStatusCode.OK, "ok"));
}
return(req.CreateResponse(HttpStatusCode.BadRequest));
}
