public object GetComponentsUrl()
{
if (Components != null)
{
return NeeoUrlBuilder.BuildResourceUrls(this);
}
throw new ApplicationException("404");
}
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);
}
/// <summary>
///
/// </summary>
/// <param name="user"></param>
/// <param name="file"></param>
/// <param name="fileCategory"></param>
/// <param name="recipientCount"></param>
/// <param name="isOverloaded"></param>
/// <returns></returns>
public static bool Save(NeeoUser user, File file, FileCategory fileCategory, ushort recipientCount = 0, bool isOverloaded = true)
{
bool isOperationCompleted = false;
file.Info.Name = NeeoUtility.IsNullOrEmpty(file.Info.Name) ? Guid.NewGuid().ToString("N") : file.Info.Name;
var server = FileServerManager.GetInstance().SelectServer();
DbManager dbManager = new DbManager();
file.Info.FullPath = server.GetServerNetworkPath();
try
{
//file.Info.CreationTimeUtc = DateTime.UtcNow;
FileManager.Save(file, FileCategory.Shared);
if (dbManager.StartTransaction())
{
if (dbManager.InsertSharedFileInformation(file.Info.Name, file.Info.Creator, Convert.ToUInt16(file.Info.MediaType), Convert.ToUInt16(file.Info.MimeType),
Path.Combine(file.Info.FullPath, file.Info.FullName), file.Info.CreationTimeUtc, recipientCount, file.Info.Length, file.Info.Hash))
{
file.Info.Url = NeeoUrlBuilder.BuildFileUrl(server.LiveDomain, file.Info.Name, FileCategory.Shared, file.Info.MediaType);
dbManager.CommitTransaction();
isOperationCompleted = true;
}
else
{
dbManager.RollbackTransaction();
}
}
}
catch (ApplicationException appException)
{
dbManager.RollbackTransaction();
throw;
}
catch (Exception exception)
{
dbManager.RollbackTransaction();
LogManager.CurrentInstance.ErrorLogger.LogError(MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
throw new ApplicationException(CustomHttpStatusCode.ServerInternalError.ToString("D"));
}
return(isOperationCompleted);
}
public HttpResponseMessage GetUserAvatar([FromUri] GetUserAvatarRequest request)
{
if (request == null || !ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
LogRequest(request);
ulong temp = 0;
//uID = HttpUtility.UrlEncode(uID);
request.Uid = request.Uid.Trim();
NeeoUser user = new NeeoUser(request.Uid);
NeeoFileInfo filePath = null;
ulong avatarTimeStamp;
switch (user.GetAvatarState(request.Ts, out avatarTimeStamp, out filePath))
{
case AvatarState.NotExist:
return(Request.CreateResponse(HttpStatusCode.NotFound));
case AvatarState.Modified:
string url = NeeoUrlBuilder.BuildAvatarUrl(request.Uid, request.Ts, request.Dim);
return(RedirectServiceToUrl(url, avatarTimeStamp));
case AvatarState.NotModified:
return(Request.CreateResponse(HttpStatusCode.NotModified));
default:
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
//}
//else
//{
// NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
//}
}
public HttpResponseMessage Get([FromUri] GetGroupIconRequest request)
{
LogRequest(request);
ulong temp = 0;
if (NeeoUtility.IsNullOrEmpty(request.Uid) || !ulong.TryParse(request.Uid, out temp) ||
NeeoUtility.IsNullOrEmpty(request.gID))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
else
{
request.Uid = request.Uid.Trim();
request.gID = request.gID.ToLower();
try
{
if (NeeoGroup.GroupIconExists(request.gID.ToLower()))
{
string url =
NeeoUrlBuilder.BuildFileUrl(ConfigurationManager.AppSettings[NeeoConstants.FileServerUrl], request.gID,
FileCategory.Group, MediaType.Image);
return(RedirectServiceToUrl(url));
}
else
{
return(Request.CreateResponse(HttpStatusCode.NotFound));
}
}
catch (Exception exception)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name, exception);
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
}
/// <summary>
///
/// </summary>
/// <param name="uID"></param>
/// <param name="gID"></param>
/// <param name="reqType"></param>
public void GetGroupIcon(string uID, string gID, string reqType = "GET")
{
#region log user request and response
/***********************************************
* To log user request
***********************************************/
if (_logRequestResponse)
{
LogManager.CurrentInstance.InfoLogger.LogInfo(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
"Request ===> senderID : " + uID + ", groupID : " + gID);
}
#endregion
// #region Verify User
//var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
//string keyFromClient = request.Headers["key"];
//if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
//{
// #endregion
ulong temp = 0;
if (NeeoUtility.IsNullOrEmpty(uID) || !ulong.TryParse(uID, out temp) ||
NeeoUtility.IsNullOrEmpty(gID))
{
NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
}
else
{
uID = uID.Trim();
gID = gID.ToLower();
try
{
if (!NeeoGroup.GroupIconExists(gID))
{
NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotFound);
}
else
{
string url =
NeeoUrlBuilder.BuildFileUrl(ConfigurationManager.AppSettings[NeeoConstants.FileServerUrl], gID,
FileCategory.Group, MediaType.Image);
RedirectServiceToUrl(url);
}
}
catch (Exception exception)
{
LogManager.CurrentInstance.ErrorLogger.LogError(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name, exception);
NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError);
}
}
//}
//else
//{
// NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
//}
}
/// <summary>
/// Gets the user's avatar base on the previous time stamp of the avatar.
/// </summary>
/// <param name="userID">A string containing the user id.</param>
/// <param name="timeStamp">An integer containing the time stamp that has to be matched with the existing image. It is optional.</param>
/// <param name="requiredDimension">An integer specifying the dimension of the image required. It is optional.</param>
public void GetUserAvatar(string userID, ulong timeStamp, uint requiredDimension)
{
userID = (userID != null) ? userID.Trim() : userID;
#region log user request and response
/***********************************************
* To log user request and response
***********************************************/
if (_logRequestResponse)
{
LogManager.CurrentInstance.InfoLogger.LogInfo(
System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
"Request ===> userID : " + userID + ", timeStamp : " + timeStamp +
", requiredDimension : " + requiredDimension);
}
#endregion
// #region Verify User
//var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
//string keyFromClient = request.Headers["key"];
//if (NeeoUtility.AuthenticateUserRequest(userID, keyFromClient))
//{
// #endregion
ulong temp = 0;
if (NeeoUtility.IsNullOrEmpty(userID) || !ulong.TryParse(userID, out temp))
{
NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.BadRequest);
}
else
{
userID = HttpUtility.UrlEncode(userID);
NeeoUser user = new NeeoUser(userID);
NeeoFileInfo fileInfo = null;
ulong avatarTimeStamp;
switch (user.GetAvatarState(timeStamp, out avatarTimeStamp, out fileInfo))
{
case AvatarState.NotExist:
NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotFound);
break;
case AvatarState.Modified:
string url = NeeoUrlBuilder.BuildAvatarUrl(userID, timeStamp, requiredDimension);
RedirectServiceToUrl(url, avatarTimeStamp);
break;
case AvatarState.NotModified:
NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.NotModified);
break;
}
}
//}
//else
//{
// NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
//}
}