} // func GetDatasetResourceFile
/// <summary>Process webrequest, return schema.xml and resource files (client scripts).</summary>
/// <param name="r"></param>
/// <returns></returns>
protected override async Task <bool> OnProcessRequestAsync(IDEWebRequestScope r)
{
if (r.RelativeSubPath == "schema.xml")
{
await Task.Run(() => DataSetDefinition.WriteToDEContext(r, ConfigPath + "/schema.xml"));
return(true);
}
else if (GetDatasetResourceFile(r.RelativeSubPath, out var fi))
{
if (MimeTypeMapping.TryGetMimeTypeFromExtension(fi.Extension, out var mimeType))
{
if (mimeType == MimeTypes.Text.Lua || mimeType == MimeTypes.Text.Html) // map lua,html to plain text, do not change content
{
mimeType = MimeTypes.Text.Plain;
}
}
else
{
mimeType = MimeTypes.Application.OctetStream;
}
await Task.Run(() => r.WriteFile(fi.FullName, mimeType));
return(true);
}
return(await base.OnProcessRequestAsync(r));
} // proc OnProcessRequest
public async Task <HttpResponseMessage> UploadMultipartAsync()
{
string fileId = null;
if (!Request.Headers.Contains("uid"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (Request.Headers.Contains("id"))
{
fileId = Request.Headers.GetValues("id").First();
}
string uId = Request.Headers.GetValues("uid").First();
if (Request.Content.IsMimeMultipartContent())
{
MultipartMemoryStreamProvider provider = await Request.Content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider());
foreach (HttpContent content in provider.Contents)
{
if (content.Headers.ContentType == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (content.Headers.ContentDisposition.FileName == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
string contentType = content.Headers.ContentType.ToString();
string sourceExtension = content.Headers.ContentDisposition.FileName.Split(new char[] { '.' }).Last().Split(new char[] { '"' }).First();
if (!MimeTypeMapping.ValidateMimeType(contentType))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
using (var stream = content.ReadAsStreamAsync().Result)
{
File uploadedFile = FileFactory.Create(contentType);
uploadedFile.Info.Name = fileId;
//file.Info.Extension = "." + sourceExtension;
uploadedFile.Info.Creator = uId;
uploadedFile.Info.Length = Convert.ToInt64(content.Headers.ContentLength);
uploadedFile.FileStream = new FileDataStream()
{
Stream = stream
};
SharedMedia.Save(new NeeoUser(uId), uploadedFile, FileCategory.Shared, 0);
var response = new HttpResponseMessage();
response.StatusCode = HttpStatusCode.OK;
response.Headers.Location = new Uri(uploadedFile.Info.Url);
return(response);
}
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
public async Task <HttpResponseMessage> UploadResumableAsync()
{
var uploadingFileInfo = new NeeoFileInfo();
if (!Request.Headers.Contains("uid"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (Request.Headers.Contains("id"))
{
uploadingFileInfo.Name = Request.Headers.GetValues("id").First();
}
else
{
uploadingFileInfo.Name = Guid.NewGuid().ToString("N");
}
if (!Request.Headers.Contains("upload-content-type"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (!Request.Headers.Contains("upload-content-length"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (!Request.Headers.Contains("filename"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var contentType = Request.Headers.GetValues("upload-content-type").First();
if (!MimeTypeMapping.ValidateMimeType(contentType))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var mimeTypeDetail = MimeTypeMapping.GetMimeTypeDetail(contentType);
uploadingFileInfo.Creator = Request.Headers.GetValues("uid").First();
uploadingFileInfo.Length = Convert.ToInt64(Request.Headers.GetValues("upload-content-length").First());
uploadingFileInfo.MimeType = mimeTypeDetail.MimeType;
uploadingFileInfo.MediaType = mimeTypeDetail.MediaType;
uploadingFileInfo.Extension = mimeTypeDetail.Extension;
var session = await UploadSessionManager.CreateSessionAsync(uploadingFileInfo);
if (session == null)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Headers.Add("id", uploadingFileInfo.Name);
response.Headers.Location = new Uri(NeeoUrlBuilder.BuildResumableUploadUrl(session.SessionID));
return(response);
}
public void MimeTypeGet()
{
Assert.IsTrue(MimeTypeMapping.TryGetMapping(MimeTypes.Text.Plain, out var mapping));
Assert.AreEqual(".txt", mapping.Extensions[0]);
Assert.IsFalse(mapping.IsCompressedContent);
MimeTypeMapping.Update("quark", false, true, ".quark", ".txt");
Assert.AreEqual(".quark", MimeTypeMapping.GetExtensionFromMimeType("quark"));
Assert.AreEqual("quark", MimeTypeMapping.GetMimeTypeFromExtension(".quark"));
MimeTypeMapping.Update(MimeTypes.Text.Plain, false, false, ".txt", ".text");
Assert.AreEqual(MimeTypes.Text.Plain, MimeTypeMapping.GetMimeTypeFromExtension(".text"));
}
/// <summary>
/// Uploads a new file
/// <para>Podio API Reference: https://developers.podio.com/doc/files/upload-file-1004361 </para>
/// </summary>
/// <param name="filePath">Full physical path to the file</param>
/// <param name="fileName">File Name with extension</param>
/// <returns></returns>
public async Task <FileAttachment> UploadFile(string filePath, string fileName)
{
if (!string.IsNullOrEmpty(filePath) && File.Exists(filePath))
{
byte[] data = await FileUtils.ReadAllBytesAsync(filePath);
string mimeType = MimeTypeMapping.GetMimeType(Path.GetExtension(filePath));
return(await UploadFile(fileName, data, mimeType));
}
else
{
throw new FileNotFoundException("File not found in the specified path");
}
}
public async Task <HttpResponseMessage> Get([FromUri] AvatarRequest avatarRequest)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Bad Request"));
}
try
{
return(await Task <HttpResponseMessage> .Factory.StartNew(() =>
{
NeeoFileInfo fileInfo = null;
ulong avatarUpdatedTimeStamp = 0;
int dimension = Convert.ToInt32(avatarRequest.Dimension);
NeeoUser user = new NeeoUser(avatarRequest.Uid);
switch (user.GetAvatarState(avatarRequest.Timestamp, false, out avatarUpdatedTimeStamp, out fileInfo))
{
case AvatarState.Modified:
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Headers.Add("ts", avatarUpdatedTimeStamp.ToString());
response.Content =
new ByteArrayContent(MediaUtility.ResizeImage(fileInfo.FullPath, dimension, dimension));
//response.Content = new StreamContent(new FileStream(fileInfo.FullPath,FileMode.Open));
response.Content.Headers.ContentType =
new MediaTypeHeaderValue(
MimeTypeMapping.GetMimeType(fileInfo.Extension).GetDescription());
return response;
case AvatarState.NotModified:
return Request.CreateResponse(HttpStatusCode.NotModified);
default:
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
}));
}
catch (AggregateException aggregateException)
{
Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, aggregateException.Message, aggregateException, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name);
}
catch (Exception exception)
{
Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception, System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name);
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
} // proc WriteAsync
public override async Task WriteAsync(XmlWriter xml, IDataRow row)
{
var objkIdKey = GetValue(row);
if (objkIdKey == null)
{
return;
}
var objkId = objkIdKey.ChangeType <long>();
// check cache
if (session.exportedImages.TryGetValue(objkId, out var fi) && fi != null)
{
await WriteAsync(xml, fi);
return;
}
// mark as exported
session.exportedImages[objkId] = null;
// test if the object is an image
var obj = session.application.Objects.GetObject(objkId);
if (obj.MimeType != MimeTypes.Image.Jpeg &&
obj.MimeType != MimeTypes.Image.Png &&
obj.MimeType != MimeTypes.Application.Pdf)
{
return;
}
// write object to disc
// todo: optimize to use direct link
fi = session.CreateTempFile(objkId.ToString() + MimeTypeMapping.GetExtensionFromMimeType(obj.MimeType), true);
using (var dst = fi.OpenWrite())
using (var src = obj.GetDataStream())
await src.CopyToAsync(dst);
await WriteAsync(xml, fi);
session.exportedImages[objkId] = fi;
} // proc WriteAsnyc
public HttpResponseMessage Get([FromUri] FileRequest fileRequest)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Bad Request"));
}
if (NeeoUtility.GenerateSignature(fileRequest.Name + fileRequest.FileCategory.ToString("D") + fileRequest.MediaType.ToString("D")) == fileRequest.Signature)
{
byte[] fileBytes;
var file = GetRequestedFile(fileRequest);
if (file != null)
{
if (Request.Headers.Range != null)
{
var delimeter = new char[] { '-', '=' };
var rangeValues = Request.Headers.Range.ToString().Split(delimeter);
if (rangeValues.Length != 3)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (!((Convert.ToInt64(rangeValues[1]) <= Convert.ToInt64(rangeValues[2])) && (Convert.ToInt64(rangeValues[2]) <= file.Info.Length)))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
fileBytes = File.GetBytesArray(file.Info.FullPath, Convert.ToInt32(rangeValues[1]),
Convert.ToInt32(rangeValues[2]));
}
else
{
fileBytes = File.GetBytesArray(file.Info.FullPath);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new ByteArrayContent(fileBytes);
//new StreamContent(File.GetStream(file.Info.FullPath));
//response.Content = new StreamContent(new FileStream(fileInfo.FullPath,FileMode.Open));
response.Content.Headers.ContentType =
new MediaTypeHeaderValue(
MimeTypeMapping.GetMimeType(file.Info.Extension).GetDescription());
return(response);
}
Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "File ID: " + fileRequest.FullName + ", File Category: Shared, Status: File does not exists.");
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Bad Request"));
}
public FileContent GetFileAttachment(Guid fileId)
{
var result = fileAttachmentRepository.GetAll().Where(t => t.Id == fileId)
.Select(t => new FileContent()
{
Id = t.Id,
AttachmentType = (FileAttachmentType)t.AttachmentTypeValue,
Extension = t.Extension,
FileName = t.FileName,
Path = t.Path,
PhysicalName = t.PhysicalName,
RelatedId = t.RelatedId,
}).FirstOrDefault();
if (result == null)
{
return(null);
}
var uploadPath = AppSetting.Get <string>("FileUploadPath");
if (!string.IsNullOrWhiteSpace(result.Path))
{
if (result.Path != "upload")
{
uploadPath = Path.Combine(uploadPath, result.Path);
}
}
var filePath = Path.Combine(uploadPath, result.PhysicalName);
result.MimeType = MimeTypeMapping.GetMimeType(result.Extension ?? "");
if (!System.IO.File.Exists(filePath))
{
throw new ResourceNotFoundException();
}
var stream = System.IO.File.OpenRead(filePath);
result.FileStream = stream;
return(result);
}
public FileInfo GetLocalTempFileInfo(PpsObject obj)
{
// create temp directory
var tempDirectory = new DirectoryInfo(Path.Combine(LocalPath.FullName, "tmp"));
if (!tempDirectory.Exists)
{
tempDirectory.Create();
}
// build filename
if (obj.TryGetProperty <string>(PpsObjectBlobData.FileNameTag, out var fileName))
{
fileName = obj.Guid.ToString("N") + "_" + fileName;
}
else
{
fileName = obj.Guid.ToString("N") + MimeTypeMapping.GetExtensionFromMimeType(obj.MimeType);
}
return(new FileInfo(Path.Combine(tempDirectory.FullName, fileName)));
} // func GetLocalTempFileInfo
public async Task <HttpResponseMessage> Put([FromUri] string type, [FromUri] string sessionID)
{
long startingPosition = 0;
try
{
if (type != "resumable" || NeeoUtility.IsNullOrEmpty(sessionID))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
var session = await UploadSessionManager.ValidateSessionAsync(sessionID);
if (session == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
session.FileInfo.Extension =
MimeTypeMapping.GetMimeTypeDetail(session.FileInfo.MimeType.GetDescription()).Extension;
long? contentLength = Request.Content.Headers.ContentLength;
string contentType = Request.Content.Headers.ContentType == null
? null
: Request.Content.Headers.ContentType.ToString();
if (Request.Content.Headers.Contains("Content-Range"))
{
var contentRange = Request.Content.Headers.GetValues("Content-Range").First();
if (contentRange == "bytes */*")
{
var file = SharedMedia.GetMedia(session.FileInfo.Name, session.FileInfo.MediaType);
if (file != null)
{
var response = Request.CreateResponse((HttpStatusCode)308);
response.Headers.Add("Range", "bytes=0-" + file.Info.Length);
response.ReasonPhrase = "Resumable Incomplete";
return(response);
}
else
{
var response = Request.CreateResponse((HttpStatusCode)308);
response.Headers.Add("Range", "bytes=0-0");
response.ReasonPhrase = "Resumable Incomplete";
return(response);
}
}
else
{
var delimeter = new char[] { '-', '/', ' ' };
var rangeValues = contentRange.Split(delimeter);
if (rangeValues.Length != 4)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (Convert.ToInt64(rangeValues[2]) != session.FileInfo.Length)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
startingPosition = Convert.ToInt64(rangeValues[1]);
}
}
if (contentLength == null || contentLength > (long)session.FileInfo.Length)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
using (var stream = await Request.Content.ReadAsStreamAsync())
{
var newFile = new File()
{
Info = session.FileInfo,
FileStream = new FileDataStream()
{
Stream = stream,
Postion = startingPosition
}
};
if (SharedMedia.Save(new NeeoUser(session.FileInfo.Creator), newFile, FileCategory.Shared, 0))
{
// check the length of the file with the database then delete it.
await UploadSessionManager.DeleteSessionAsync(sessionID);
var response = new HttpResponseMessage(HttpStatusCode.Created);
response.Headers.Location = new Uri(newFile.Info.Url);
return(response);
}
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
catch (Exception exception)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public static void Android_OpenFileUrl(string filePath)
{
if (string.IsNullOrEmpty(filePath))
{
return;
}
if (string.IsNullOrEmpty(filePath))
{
return;
}
using (var intent = new AndroidJavaObject("android.content.Intent"))
{
int ANDROID_SDK_NOUGAT = 24;
AndroidJavaObject activity = new AndroidJavaClass("com.unity3d.player.UnityPlayer").GetStatic <AndroidJavaObject>("currentActivity");
//Permission to read URI
intent.Call <AndroidJavaObject>("addFlags", intent.GetStatic <int>("FLAG_GRANT_READ_URI_PERMISSION"));
intent.Call <AndroidJavaObject>("setAction", intent.GetStatic <string>("ACTION_VIEW"));
//Get API Android Version
var apiLevel = new AndroidJavaClass("android.os.Build$VERSION").GetStatic <int>("SDK_INT");
var mimeType = "";
AndroidJavaObject uri;
if (apiLevel > ANDROID_SDK_NOUGAT)
{
//New version, need a fileprovider
var context = activity.Call <AndroidJavaObject>("getApplicationContext");
var fileProvider = new AndroidJavaClass("com.yasirkula.unity.NativeShareContentProvider");
var authority = Android_GetAuthority();
var file = new AndroidJavaObject("java.io.File", filePath);
uri = fileProvider.CallStatic <AndroidJavaObject>("getUriForFile", context, authority, file);
mimeType = fileProvider.Call <string>("getType", uri);
}
else
{
//Old version using uriClass
var uriClass = new AndroidJavaClass("android.net.Uri");
var file = new AndroidJavaObject("java.io.File", filePath);
uri = uriClass.CallStatic <AndroidJavaObject>("fromFile", file);
mimeType = MimeTypeMapping.GetMimeMapping(filePath);
}
if (string.IsNullOrEmpty(mimeType))
{
mimeType = "application/octet-stream";
}
//Set MimeType
intent.Call <AndroidJavaObject>("setType", mimeType);
//Set Uri
intent.Call <AndroidJavaObject>("setData", uri);
//start activity
activity.Call("startActivity", intent);
}
}
public async Task <HttpResponseMessage> PostUserInformation()
{
if (!Request.Headers.Contains("uid"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (!Request.Headers.Contains("name"))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
string uId = Request.Headers.GetValues("uid").First();
string name = Request.Headers.GetValues("name").First();;
bool isUpdated = false;
if (Request.Content.IsMimeMultipartContent())
{
MultipartMemoryStreamProvider provider = await Request.Content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider());
foreach (HttpContent content in provider.Contents)
{
if (content.Headers.ContentType == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
if (content.Headers.ContentDisposition.FileName == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
string contentType = content.Headers.ContentType.ToString();
string sourceExtension = content.Headers.ContentDisposition.FileName.Split(new char[] { '.' }).Last().Split(new char[] { '"' }).First();
if (!MimeTypeMapping.ValidateMimeType(contentType))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
using (var stream = content.ReadAsStreamAsync().Result)
{
NeeoUser user = new NeeoUser(uId);
try
{
isUpdated = user.UpdateUserProfile(name, new LibNeeo.IO.File()
{
FileStream = new FileDataStream()
{
Stream = stream
}
});
return(Request.CreateResponse(HttpStatusCode.OK, isUpdated));
}
catch (ApplicationException appExp)
{
return(SetCustomResponseMessage(isUpdated, (HttpStatusCode)(Convert.ToInt32(appExp.Message))));
}
catch (Exception exp)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
return(SetCustomResponseMessage(isUpdated, (HttpStatusCode)CustomHttpStatusCode.ServerInternalError));
}
}
}
}
else
{
NeeoUser user = new NeeoUser(uId);
try
{
isUpdated = user.UpdateUserProfile(name, null);
return(Request.CreateResponse(HttpStatusCode.OK, isUpdated));
}
catch (ApplicationException appExp)
{
return(SetCustomResponseMessage(isUpdated, (HttpStatusCode)(Convert.ToInt32(appExp.Message))));
}
catch (Exception exp)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
return(SetCustomResponseMessage(isUpdated, (HttpStatusCode)CustomHttpStatusCode.ServerInternalError));
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
