Ejemplo n.º 1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="name"></param>
        /// <param name="file"></param>
        /// <returns></returns>
        public bool UpdateUserProfile(string name, LibNeeo.IO.File file)
        {
            bool isCompleted = false;

            if (!UpdateUsersDisplayName(name))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidUser);
            }
            else if (file == null)
            {
                isCompleted = true;
            }
            else
            {
                file.Info = new NeeoFileInfo()
                {
                    Name = _userID, Creator = _userID, MediaType = MediaType.Image, MimeType = MimeType.ImageJpeg
                };

                if (FileManager.Save(file, FileCategory.Profile))
                {
                    isCompleted = true;
                }
            }
            return(isCompleted);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Deletes the expired files from file servers.
        /// </summary>
        public static void DeleteExpiredFiles()
        {
            const string delimeter    = ",";
            const string expiryPeriod = "expiryPeriod";
            DbManager    dbManager    = new DbManager();

            DataTable dtExpiredFiles = dbManager.GetExpiredFile(DateTime.UtcNow, Convert.ToInt16(ConfigurationManager.AppSettings[expiryPeriod]));
            string    recordIDs      = "";

            foreach (DataRow dr in dtExpiredFiles.Rows)
            {
                try
                {
                    if (File.Delete(dr["fullPath"].ToString()))
                    {
                        recordIDs += dr["id"].ToString() + ",";
                    }
                }
                catch (Exception exception)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        MethodBase.GetCurrentMethod().DeclaringType, exception.Message, exception);
                }
            }
            if (recordIDs != string.Empty)
            {
                dbManager.DeleteSharedFile(recordIDs, delimeter);
            }
        }
Ejemplo n.º 3
0
        protected void SetResponseWithFileData(LibNeeo.IO.File file)
        {
            string contentType = file.Info.MimeType.GetDescription();

            if (file.Info.MimeType == MimeType.DocWordx)
            {
                contentType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
            }

            if (file.Info.MimeType == MimeType.DocPptx)
            {
                contentType = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
            }

            if (file.Info.MimeType == MimeType.DocXlsx)
            {
                contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
            }

            _httpContext.Response.ClearContent();
            _httpContext.Response.ClearHeaders();
            _httpContext.Response.Buffer      = true;
            _httpContext.Response.ContentType = contentType;
            _httpContext.Response.AddHeader("Content-Length", file.Info.Length.ToString());
            _httpContext.Response.TransmitFile(file.Info.FullPath);
            //_httpContext.Response.AddHeader("Ext", MimeTypeMapping.GetMimeTypeDetail(file.Info.MimeType.GetDescription()).Extension);
            //_httpContext.Response.BinaryWrite(System.IO.File.ReadAllBytes(file.Info.FullPath));
            _httpContext.Response.Flush();
            _httpContext.Response.End();
        }
Ejemplo n.º 4
0
 /// <summary>
 /// Gets the user's avatar base on the file path of avatar.
 /// </summary>
 /// <returns>It returns Avatar if exists.</returns>
 public Stream GetAvatarStream()
 {
     LibNeeo.IO.File file = FileManager.GetFile(_userID, FileCategory.Profile, MediaType.Image);
     if (file != null)
     {
         return(LibNeeo.IO.File.GetStream(file.Info.FullPath));
     }
     return(null);
 }
Ejemplo n.º 5
0
        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));
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Processes the http request to send the required response.
        /// </summary>
        /// <remarks>It is used to send image data to the requester if the request  </remarks>
        /// <param name="context">An object holding http context object for setting up response header on sending response.</param>
        public void ProcessRequest(HttpContext context)
        {
            _httpContext = context;
            LibNeeo.IO.File file      = null;
            ulong           timeStamp = 0;
            short           fileClass = 0;

            if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["id"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["sig"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["fc"]) &&
                !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["mt"]))
            {
                string       fileID       = HttpUtility.UrlEncode(context.Request.QueryString["id"].ToString());
                FileCategory fileCategory = (FileCategory)Convert.ToInt16(context.Request.QueryString["fc"]);
                MediaType    mediaType    = (MediaType)Convert.ToInt16(context.Request.QueryString["mt"]);

                if (NeeoUtility.GenerateSignature(fileID + fileCategory.ToString("D") + mediaType.ToString("D")) == context.Request.QueryString["sig"].ToString())
                {
                    file = GetRequestedFile(fileID, fileCategory, mediaType);
                    if (file != null)
                    {
                        SetResponseWithFileData(file);
                    }
                    else
                    {
                        Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "File ID: " + fileID + ", File Category: Shared, Status: File does not exists.");
                    }
                }
            }
            else if (!NeeoUtility.IsNullOrEmpty(context.Request.QueryString["id"]) &&
                     !NeeoUtility.IsNullOrEmpty(context.Request.QueryString["sig"]))
            {
                // This part is to give backward compatibility for shared file service given with release 3
                string fileID = HttpUtility.UrlEncode(context.Request.QueryString["id"].ToString());

                if (NeeoUtility.GenerateSignature(fileID) == context.Request.QueryString["sig"].ToString())
                {
                    file = GetRequestedFile(fileID, FileCategory.Shared, MediaType.Image);
                    if (file != null)
                    {
                        SetResponseWithFileData(file);
                    }
                    else
                    {
                        Logger.LogManager.CurrentInstance.ErrorLogger.LogError(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "File ID: " + fileID + ", File Category: Group, Status: File does not exists.");
                    }
                }
            }
            SetResponseHeaders((int)HttpStatusCode.BadRequest);
        }
Ejemplo n.º 7
0
        public HttpResponseMessage Post([FromBody] UploadGroupIconRequest request)
        {
            if (!ModelState.IsValid)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
            LogRequest(request);
            ulong temp = 0;

            request.Uid = request.Uid.Trim();
            request.gID = request.gID.ToLower();
            try
            {
                var file = new LibNeeo.IO.File()
                {
                    Info = new NeeoFileInfo()
                    {
                        Creator   = request.Uid,
                        MimeType  = MimeType.ImageJpeg,
                        MediaType = MediaType.Image
                    },
                    Data = request.data,
                };
                if (NeeoGroup.SaveGroupIcon(request.Uid, request.gID.ToLower(), file))
                {
                    return(Request.CreateResponse(HttpStatusCode.OK));
                }
                else
                {
                    return(Request.CreateResponse(HttpStatusCode.InternalServerError));
                }
            }
            catch (ApplicationException appExp)
            {
                return(SetCustomResponseMessage("", (HttpStatusCode)(CustomHttpStatusCode)(Convert.ToInt32(appExp.Message))));
            }
            catch (Exception exception)
            {
                LogManager.CurrentInstance.ErrorLogger.LogError(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name, exception);
                return(SetCustomResponseMessage("", (HttpStatusCode)CustomHttpStatusCode.ServerInternalError));
            }
        }
Ejemplo n.º 8
0
        /// <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);
        }
Ejemplo n.º 9
0
        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));
            }
        }
Ejemplo n.º 10
0
        public async Task <HttpResponseMessage> UploadDataAsync(ApiController controller)
        {
            if (controller.Request.Content.Headers.ContentType == null)
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (Request.Content.Headers.ContentType.ToString().Split(new char[] { ';' })[0] != "application/json")
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            var requestBody = await Request.Content.ReadAsStringAsync();

            var fileRequest = JsonConvert.DeserializeObject <UploadFileRequest>(requestBody);

            controller.Validate(fileRequest);

            if (!ModelState.IsValid)
            {
                return(controller.Request.CreateResponse(HttpStatusCode.BadRequest));
            }

            if (!NeeoUtility.IsNullOrEmpty(fileRequest.FId))
            {
                Guid resultingGuid;
                if (!Guid.TryParse(fileRequest.FId, out resultingGuid))
                {
                    LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                                                                  "fID : " + fileRequest.FId + " is not parseable.");
                    return(Request.CreateResponse(HttpStatusCode.BadRequest));
                }
                fileRequest.FId = resultingGuid.ToString("N").ToLower();
            }

            NeeoUser sender = new NeeoUser(fileRequest.Uid);

            File uploadedFile = FileFactory.Create(fileRequest.MimeType.GetDescription());

            uploadedFile.Info.Name    = fileRequest.FId;
            uploadedFile.Info.Creator = fileRequest.Uid;
            uploadedFile.Data         = fileRequest.Data;
            //LibNeeo.IO.File uploadingFile = new LibNeeo.IO.File()
            //{
            //    Info = new NeeoFileInfo()
            //    {

            //        MediaType = MediaType.Image,
            //        MimeType = fileRequest.MimeType,

            //        Extension = "jpg"
            //    },
            //    Data = fileRequest.Data
            //};

            SharedMedia.Save(sender, uploadedFile, FileCategory.Shared, 0);

            #region log user request and response

            /***********************************************
            *       To log user response
            ***********************************************/
            if (_logRequestResponse)
            {
                LogManager.CurrentInstance.InfoLogger.LogInfo(
                    System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                    "Response ===> " + uploadedFile.Info.Url);
            }

            #endregion log user request and response

            return(Request.CreateResponse(HttpStatusCode.OK,
                                          new Dictionary <string, string>()
            {
                { "UploadFileResult", uploadedFile.Info.Url }
            }));
        }
Ejemplo n.º 11
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="uID"></param>
        /// <param name="data"></param>
        /// <param name="gID"></param>
        public void UploadGroupIcon(string uID, string data, string gID)
        {
            ulong temp = 0;

            uID = (uID != null) ? uID.Trim() : uID;

            #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


            if (NeeoUtility.IsNullOrEmpty(uID) || !ulong.TryParse(uID, out temp) ||
                NeeoUtility.IsNullOrEmpty(data) ||
                NeeoUtility.IsNullOrEmpty(gID))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            else
            {
                gID = gID.ToLower();
                try
                {
                    var file = new LibNeeo.IO.File()
                    {
                        Info = new NeeoFileInfo()
                        {
                            Creator   = uID,
                            MimeType  = MimeType.ImageJpeg,
                            MediaType = MediaType.Image
                        },
                        Data = data,
                    };
                    if (!NeeoGroup.SaveGroupIcon(uID, gID.ToLower(), file))
                    {
                        NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.ServerInternalError);
                    }
                }
                catch (ApplicationException appExp)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                }
                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);

            //}
        }
Ejemplo n.º 12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="uID"></param>
        /// <param name="data"></param>
        /// <param name="mimeType"></param>
        /// <param name="recipientCount"></param>
        /// <returns></returns>
        public string UploadFile(string uID, string fID, string data, ushort mimeType, ushort recipientCount)
        {
            ulong  temp      = 0;
            string resultUrl = null;

            uID = (uID != null) ? uID.Trim() : uID;
            fID = (fID != null) ? fID.Trim() : fID;
            fID = (fID != null) ? fID.Trim() : fID;


            #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 + ", mimeType : " + mimeType.ToString() + ", fID : " + fID + ", recipientCount : " + recipientCount.ToString());
            }

            #endregion

            //      #region Verify User
            //var request = OperationContext.Current.IncomingMessageProperties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            //string keyFromClient = request.Headers["key"];
            //if (NeeoUtility.AuthenticateUserRequest(uID, keyFromClient))
            //{
            //    #endregion

            if (NeeoUtility.IsNullOrEmpty(uID) && !ulong.TryParse(uID, out temp) && !Enum.IsDefined(typeof(MimeType), mimeType) && (recipientCount == 0 || recipientCount >= 255) &&
                NeeoUtility.IsNullOrEmpty(data))
            {
                NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
            }
            else
            {
                if (!NeeoUtility.IsNullOrEmpty(fID))
                {
                    Guid resultingGuid;
                    if (!Guid.TryParse(fID, out resultingGuid))
                    {
                        LogManager.CurrentInstance.InfoLogger.LogInfo(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, System.Reflection.MethodBase.GetCurrentMethod().Name + "===>" +
                                                                      "fID : " + fID + " is not parseable.");
                        NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.InvalidArguments);
                        return(resultUrl);
                    }
                    fID = resultingGuid.ToString("N").ToLower();
                }

                NeeoUser sender = new NeeoUser(uID);
                try
                {
                    LibNeeo.IO.File file = new LibNeeo.IO.File()
                    {
                        Info = new NeeoFileInfo()
                        {
                            Creator = uID, MediaType = MediaType.Image, MimeType = (MimeType)mimeType, Name = fID
                        }, Data = data
                    };
                    if (SharedMedia.Save(sender, file, FileCategory.Shared, recipientCount))
                    {
                        resultUrl = file.Info.Url;
                    }
                    #region log user request and response

                    /***********************************************
                    *  To log user response
                    ***********************************************/
                    if (_logRequestResponse)
                    {
                        LogManager.CurrentInstance.InfoLogger.LogInfo(
                            System.Reflection.MethodBase.GetCurrentMethod().DeclaringType,
                            "Response ===> " + resultUrl);
                    }

                    #endregion
                }
                catch (ApplicationException appExp)
                {
                    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)(Convert.ToInt32(appExp.Message)));
                }
                catch (Exception exp)
                {
                    LogManager.CurrentInstance.ErrorLogger.LogError(
                        System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, exp.Message, exp);
                    NeeoUtility.SetServiceResponseHeaders(CustomHttpStatusCode.UnknownError);
                }
            }
            return(resultUrl);
            //}
            //else
            //{
            //    NeeoUtility.SetServiceResponseHeaders((CustomHttpStatusCode)HttpStatusCode.Unauthorized);
            //    return resultUrl;
            //}
        }
Ejemplo n.º 13
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="userID"></param>
 /// <param name="groupID"></param>
 /// <param name="file"></param>
 /// <returns></returns>
 public static bool SaveGroupIcon(string userID, string groupID, File file)
 {
     file.Info.Name = groupID;
     return(FileManager.Save(file, FileCategory.Group));
 }