public ActionResult Upload(BlobUploadModel model)
{
model.ContentFile = Request.Files["ContentFile"];
if (model.ContentFile == null || model.ContentFile.ContentLength == 0)
{
ModelState.AddModelError("ContentFile", "Please select the file to upload.");
}
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
string filename = Path.GetFileName(model.ContentFile.FileName);
var blobName = string.IsNullOrEmpty(model.Name) ? Path.GetFileNameWithoutExtension(model.ContentFile.FileName) : model.Name;
var blob = new Blob()
{
Name = blobName,
Description = model.Description,
OriginalFileName = filename,
UploadDateTime = DateTime.UtcNow
};
Guid blobId = this.blobService.UploadBlob(blob, model.ContentFile.InputStream);
return(RedirectToAction("Details", new { id = blobId }));
}
public async Task <BlobUploadModel> Upload(Guid userId, string fileName, Stream fileStream, string contentType = "application/jpeg")
{
ExceptionHelper.ThrowArgumentNullIfEmpty(userId, nameof(userId));
ExceptionHelper.ThrowParameterNullIfEmpty(fileName, nameof(fileName));
var blobName = GetFullBlobName(userId);
var blobClient = GetBlobClient(userId, blobName);
var response = await blobClient.UploadAsync(fileStream,
new BlobHttpHeaders
{
ContentType = contentType
});
ExceptionHelper.ThrowNotFoundIfEmpty(response, "Blob");
var createModel = new BlobModel
{
ImageName = fileName,
UserId = userId
};
var createdBlob = await _blobDataService.Create(createModel, blobName);
var result = new BlobUploadModel
{
Blob = createdBlob,
BlobContentInfo = response.Value
};
return(result);
}
public ActionResult Upload()
{
string message = null;
if (Request.QueryString["FileTooLarge"] != null)
{
int maxRequestLength = 0;
System.Web.Configuration.HttpRuntimeSection section =
(System.Web.Configuration.HttpRuntimeSection)
System.Web.Configuration.WebConfigurationManager.GetWebApplicationSection("system.web/httpRuntime");
if (section != null)
{
maxRequestLength = section.MaxRequestLength;
}
message = string.Format("File is too large. Use multiple file upload for files larger than {0}KB.", maxRequestLength);
}
var model = new BlobUploadModel
{
UploadHandler = this.GetUploadHandlerPage(),
Message = message
};
return(this.View(model));
}
public async Task <BlobUploadModel> UploadBlob(String key, String mediaType, FileStream fileStream, BlobHelper.Repository repo)
{
var ipAddress = GetIPAddress();
var isDev = ipAddress.StartsWith("192.168");
if (isDev)
{
key = "dev-" + key;
}
// Retrieve reference to a blob
var blobContainer = BlobHelper.GetBlobContainer(repo);
var blob = blobContainer.GetBlockBlobReference(key);
// Set the blob content type
blob.Properties.ContentType = mediaType;
// Upload file into blob storage, basically copying it from local disk into Azure
fileStream.Position = 0;
blob.UploadFromStream(fileStream);
// Create blob upload model with properties from blob info
var blobUpload = new BlobUploadModel
{
FileName = blob.Name,
FileUrl = blob.Uri.AbsoluteUri,
FileSizeInBytes = blob.Properties.Length
};
return(blobUpload);
}
public async Task <bool> DeleteDocument(BlobUploadModel documentData)
{
if (IsActiveProfile)
{
return(await AzureProvider.DeleteBlobAsync(documentData.FileUrl));
}
return(false);
}
public override Task ExecutePostProcessingAsync()
{
// NOTE: FileData is a property of MultipartFileStreamProvider and is a list of multipart
// files that have been uploaded and saved to disk in the Path.GetTempPath() location.
foreach (var fileData in FileData)
{
var fs = File.OpenRead(fileData.LocalFileName);
if (!IsValidFile(fs))
{
throw new InvalidDataException("Only images are allowed to be uploaded");
}
}
foreach (var fileData in FileData)
{
// Sometimes the filename has a leading and trailing double-quote character
// when uploaded, so we trim it; otherwise, we get an illegal character exception
var fileName = Path.GetFileName(fileData.Headers.ContentDisposition.FileName.Trim('"'));
// Retrieve reference to a blob
var blobContainer = BlobHelper.GetBlobContainer(BlobHelper.Repository.Photos);
var blob = blobContainer.GetBlockBlobReference(fileName);
// Set the blob content type
blob.Properties.ContentType = fileData.Headers.ContentType.MediaType;
// Upload file into blob storage, basically copying it from local disk into Azure
using (var fs = File.OpenRead(fileData.LocalFileName))
{
blob.UploadFromStream(fs);
}
// Delete local file from disk
File.Delete(fileData.LocalFileName);
// Create blob upload model with properties from blob info
var blobUpload = new BlobUploadModel
{
FileName = blob.Name,
FileUrl = blob.Uri.AbsoluteUri,
FileSizeInBytes = blob.Properties.Length
};
// Add uploaded blob to the list
Uploads.Add(blobUpload);
}
return(base.ExecutePostProcessingAsync());
}
public ActionResult UploadBlobToContainer(BlobUploadModel uploadModel)
{
try
{
CloudBlobContainer container = GetCloudBlobContainer(uploadModel.containerName);
string containerSAS = GetContainerSasUri(container);
UploadToContainerUsingSAS(containerSAS, uploadModel.File);
ViewBag.Message = $"{uploadModel.File.FileName} Has been uploaded";
}
catch (Exception exp)
{
ViewBag.Message = $"There was an error in upload. Error message was {exp.Message}";
}
return(View());
}
public async Task <StatusResult> DeleteDocument(BlobUploadModel documentData)
{
StatusResult c = new StatusResult();
try
{
if (!ModelState.IsValid)
{
var errors = ModelState.Where(x => x.Value.Errors.Count > 0).Select(x => x.Value.Errors.Select(y => y.ErrorMessage)).ToList();
Log.Error(Logfornet.LogMessage(documentData.CompanyId, "DeleteDocument", errors.ToArray(), ""));
c.Status = Status.BadRequest.ToString();
c.Result = BadRequest();
return(c);
}
if (User.IsInRole(Roles.SuperAdmin) || User.IsInRole(Roles.PortalAdmin) || User.IsInRole(Roles.AccountAdmin))
{
InspectionConfig InspectionConfig = new InspectionConfig();
await InspectionConfig.DeleteDocument(documentData);
Log.Info(Logfornet.LogMessage(documentData.CompanyId, "DeleteDocument", ErrorMessages.Success, ""));
c.Status = Status.Success.ToString();
c.Result = "Inserted Successfully";
return(c);
}
else
{
Log.Warn(Logfornet.LogMessage(documentData.CompanyId, "DeleteDocument", ErrorMessages.NoAccessDenied, ""));
c.Status = Status.NoAccess.ToString();
c.Result = "No Access";
return(c);
}
}
catch (Exception ex)
{
Log.Error(Logfornet.LogMessage(documentData.CompanyId, "DeleteDocument", ex.Message, ex.StackTrace));
c.Status = ExceptionStatus.SqlException.ToString();
c.StatusCode = (int)ExceptionStatus.SqlException;
c.Result = ex.InnerException;
return(c);
}
}
public async Task <ActionResult> UploadInspectionDocumnets(int InspectionId, int CompanyId)
{
List <BlobUploadModel> documentData = new List <BlobUploadModel>();
// Get all files from Request object
HttpFileCollectionBase files = Request.Files;
for (int i = 0; i < files.Count; i++)
{
BlobUploadModel objBUM = new BlobUploadModel();
HttpPostedFileBase file = files[i];
byte[] fileData = null;
using (var binaryReader = new BinaryReader(file.InputStream))
{
fileData = binaryReader.ReadBytes(file.ContentLength);
}
objBUM.FileName = file.FileName;
objBUM.FileData = fileData;
documentData.Add(objBUM);
}
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userData.AccessToken);
HttpResponseMessage responseMessage = await client.PostAsJsonAsync(_url + "RoadsideInspection/UploadInspectionDocumnetss", documentData);
if (responseMessage.IsSuccessStatusCode)
{
var result = responseMessage.Content.ReadAsStringAsync().Result;
StatusResult statusResult = JsonConvert.DeserializeObject <StatusResult>(result);
if (statusResult.Status.Equals(Status.Success.ToString()))
{
//ManualRSIModel inspectionData = JsonConvert.DeserializeObject<ManualRSIModel>(statusResult.Result.ToString());
return(Json(new { status = statusResult.Status }, JsonRequestBehavior.AllowGet));
}
else if (statusResult.Status.Equals(Status.Fail.ToString()))
{
return(Json(new { status = Status.Fail.ToString() }, JsonRequestBehavior.AllowGet));
}
}
return(Json(new { status = "Error" }, JsonRequestBehavior.AllowGet));
}
public override Task ExecutePostProcessingAsync()
{
foreach (var fileData in FileData)
{
// Sometimes the filename has a leading and trailing double-quote character
// when uploaded, so we trim it; otherwise, we get an illegal character exception
var fileName = Path.GetFileName(fileData.Headers.ContentDisposition.FileName.Trim('"'));
// Retrieve reference to a blob
var blobContainer = BlobHelper.GetBlobContainer(BlobHelper.Repository.Audio);
var blob = blobContainer.GetBlockBlobReference(fileName);
// Set the blob content type
blob.Properties.ContentType = fileData.Headers.ContentType.MediaType;
// Upload file into blob storage, basically copying it from local disk into Azure
using (var fs = File.OpenRead(fileData.LocalFileName))
{
blob.UploadFromStream(fs);
}
// Delete local file from disk
File.Delete(fileData.LocalFileName);
// Create blob upload model with properties from blob info
var blobUpload = new BlobUploadModel
{
FileName = blob.Name,
FileUrl = blob.Uri.AbsoluteUri,
FileSizeInBytes = blob.Properties.Length
};
// Add uploaded blob to the list
Uploads.Add(blobUpload);
}
return(base.ExecutePostProcessingAsync());
}
public override Task ExecutePostProcessingAsync()
{
// NOTE: FileData is a property of MultipartFileStreamProvider and is a list of multipart
// files that have been uploaded and saved to disk in the Path.GetTempPath() location.
int counter = 1;
string title = "";
string model = "";
string description = "";
foreach (var fileData in FileData)
{
if (fileData.Headers.ContentDisposition.Name.Replace("\"", "") == "File")
{
// Sometimes the filename has a leading and trailing double-quote character
// when uploaded, so we trim it; otherwise, we get an illegal character exception
var fileName = Path.GetFileName(fileData.Headers.ContentDisposition.FileName.Trim('"'));
// Retrieve reference to a blob
var blobContainer = BlobHelper.GetBlobContainer();
var blob = blobContainer.GetBlockBlobReference(fileName);
// Set the blob content type
blob.Properties.ContentType = fileData.Headers.ContentType.MediaType;
// Upload file into blob storage, basically copying it from local disk into Azure
using (var fs = File.OpenRead(fileData.LocalFileName))
{
blob.UploadFromStream(fs);
}
// Delete local file from disk
File.Delete(fileData.LocalFileName);
// Create blob upload model with properties from blob info
var blobUpload = new BlobUploadModel {
FileName = blob.Name,
FileUrl = blob.Uri.AbsoluteUri,
FileSizeInBytes = blob.Properties.Length,
Title = title,
Model = model,
Description = description
};
// Add uploaded blob to the list
Uploads.Add(blobUpload);
}
else
{
switch (counter)
{
case 1:
title = fileData.Headers.ContentDisposition.Name.Replace("\"", "");
break;
case 2:
model = fileData.Headers.ContentDisposition.Name.Replace("\"", "");
break;
case 3:
description = fileData.Headers.ContentDisposition.Name.Replace("\"", "");
break;
}
}
counter++;
}
return(base.ExecutePostProcessingAsync());
}
public async Task <bool> DeleteDocument(BlobUploadModel documentData)
{
IRoadsideInspectionService inspection = new RoadsideInspectionService(documentData.CompanyId);
return(await inspection.DeleteDocument(documentData));
}
