// Token: 0x06001345 RID: 4933 RVA: 0x0004F85C File Offset: 0x0004DA5C private PhotoResponse LoadPreview(PhotoRequest request, PhotoResponse response) { Dictionary <UserPhotoSize, byte[]> dictionary = new Dictionary <UserPhotoSize, byte[]>(); try { int num = this.reader.ReadAllPreviewSizes(this.session, dictionary); this.tracer.TraceDebug <string, int>((long)this.GetHashCode(), "Preview photo upload handler: read preview photo of {0} with thumbprint {1:X8}.", request.TargetPrimarySmtpAddress, num); response.UploadedPhotos = dictionary; response.Thumbprint = new int?(num); response.PreviewUploadHandlerProcessed = true; } catch (ObjectNotFoundException arg) { this.tracer.TraceError <ObjectNotFoundException>((long)this.GetHashCode(), "Preview photo upload handler: preview photo does NOT exist in mailbox. Exception: {0}", arg); throw; } catch (StoragePermanentException arg2) { this.tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "Preview photo upload handler: hit a permanent storage exception loading preview photo from mailbox. Exception: {0}", arg2); throw; } catch (StorageTransientException arg3) { this.tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "Preview photo upload handler: hit a transient storage exception loading preview photo from mailbox. Exception: {0}", arg3); throw; } return(response); }
// Token: 0x06001344 RID: 4932 RVA: 0x0004F768 File Offset: 0x0004D968 private PhotoResponse UploadPreview(PhotoRequest request, PhotoResponse response) { if (request.RawUploadedPhoto == null || request.RawUploadedPhoto.Length == 0L) { this.tracer.TraceDebug((long)this.GetHashCode(), "Preview photo upload handler: skipped because no photo was uploaded in the request."); return(response); } request.RawUploadedPhoto.Seek(0L, SeekOrigin.Begin); int num = PhotoThumbprinter.Default.Compute(request.RawUploadedPhoto); this.tracer.TraceDebug <string, int>((long)this.GetHashCode(), "Preview photo upload handler: uploading preview photo of {0}. Its thumbprint is {1:X8}.", request.TargetPrimarySmtpAddress, num); try { this.writer.UploadPreview(num, this.CropAndScaleRawPhoto(request.RawUploadedPhoto)); response.PreviewUploadHandlerProcessed = true; } catch (StoragePermanentException arg) { this.tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "Preview photo upload handler: hit a permanent storage exception uploading photo to mailbox. Exception: {0}", arg); throw; } catch (StorageTransientException arg2) { this.tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "Preview photo upload handler: hit a transient storage exception uploading photo to mailbox. Exception: {0}", arg2); throw; } return(response); }
private int ReadThumbprintAndStampOntoResponse(PhotoRequest request, PhotoResponse response, IMailboxSession session, bool forceReloadThumbprint) { int num = this.reader.ReadThumbprint(session, request.Preview, forceReloadThumbprint); response.Thumbprint = new int?(num); return(num); }
private PhotoResponse CacheToFileSystem(PhotoRequest request, PhotoResponse response) { PhotoResponse result; using (new StopwatchPerformanceTracker("CachingHandlerCachePhoto", request.PerformanceLogger)) { using (new CpuPerformanceTracker("CachingHandlerCachePhoto", request.PerformanceLogger)) { if (!response.OutputPhotoStream.CanSeek || !response.OutputPhotoStream.CanRead) { this.tracer.TraceError((long)this.GetHashCode(), "CACHING HANDLER: skipped because photo stream is unreadable and/or not seekable."); result = response; } else { response.CachingHandlerProcessed = true; request.PerformanceLogger.Log("CachingHandlerProcessed", string.Empty, 1U); int num = this.ComputeAndStampThumbprintOntoResponse(response); response.OutputPhotoStream.Seek(0L, SeekOrigin.Begin); this.tracer.TraceDebug <string, int, long>((long)this.GetHashCode(), "CACHING HANDLER: caching photo at {0} with thumbprint {1:X8} and size {2} bytes", response.PhotoFullPathOnFileSystem, num, response.OutputPhotoStream.Length); this.writer.Write(response.PhotoFullPathOnFileSystem, num, response.OutputPhotoStream); response.PhotoWrittenToFileSystem = true; this.tracer.TraceDebug((long)this.GetHashCode(), "CACHING HANDLER: photo has been cached successfully"); result = response; } } } return(result); }
private void ClearPhotoFromFileSystem(PhotoRequest request, PhotoResponse response, FileSystemPhotoMap map, UserPhotoSize size) { int num = PhotoThumbprinter.Default.GenerateThumbprintForNegativeCache(); string text = map.Map(request.TargetPrimarySmtpAddress, size); this.tracer.TraceDebug <string, int>((long)this.GetHashCode(), "File system photo upload handler: clearing photo at {0}. Replacing it with NEGATIVE caching photo with thumbprint = {1:X8}", text, num); this.DeleteThenWritePhoto(text, num, Stream.Null); }
private PhotoResponse ServePhotoHasBeenDeleted(PhotoRequest request, PhotoResponse response) { this.tracer.TraceDebug((long)this.GetHashCode(), "MAILBOX HANDLER: photo has been deleted."); response.Served = true; response.Status = HttpStatusCode.NotFound; response.HttpExpiresHeader = UserAgentPhotoExpiresHeader.Default.ComputeExpiresHeader(DateTime.UtcNow, HttpStatusCode.NotFound, this.configuration); request.PerformanceLogger.Log("MailboxHandlerPhotoServed", string.Empty, 0U); return(response); }
// Token: 0x0600114B RID: 4427 RVA: 0x00047AF5 File Offset: 0x00045CF5 private PhotoResponse FindTargetAndReadPhoto(PhotoRequest request, PhotoResponse response) { this.ComputeTargetADObjectIdAndStampOntoRequest(request); if (request.TargetAdObjectId == null) { this.tracer.TraceDebug((long)this.GetHashCode(), "AD HANDLER: cannot serve photo because target AD object ID has not been initialized."); return(response); } return(this.ReadPhotoOntoResponse(request, response)); }
private PhotoResponse FindContactOrPersonAndServePhoto(PhotoRequest request, PhotoResponse response) { StoreObjectId storeObjectId = this.FindContactId(request); if (storeObjectId == null) { return(this.FindPersonAndServePhoto(request, response)); } return(this.ReadPhotoOffOfContactAndServe(storeObjectId, request, response)); }
private PhotoResponse ServePhotoNotModified(PhotoRequest request, PhotoResponse response) { this.tracer.TraceDebug <string>((long)this.GetHashCode(), "MAILBOX HANDLER: NOT MODIFIED. Requestor already has photo cached. ETag: {0}", request.ETag); response.Served = true; response.Status = HttpStatusCode.NotModified; response.HttpExpiresHeader = UserAgentPhotoExpiresHeader.Default.ComputeExpiresHeader(DateTime.UtcNow, HttpStatusCode.NotModified, this.configuration); request.PerformanceLogger.Log("MailboxHandlerPhotoAvailable", string.Empty, 1U); request.PerformanceLogger.Log("MailboxHandlerPhotoServed", string.Empty, 1U); return(response); }
// Token: 0x06001149 RID: 4425 RVA: 0x000478C4 File Offset: 0x00045AC4 public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { PhotoResponse result; using (new StopwatchPerformanceTracker("ADHandlerTotal", request.PerformanceLogger)) { using (new ADPerformanceTracker("ADHandlerTotal", request.PerformanceLogger)) { if (request.ShouldSkipHandlers(PhotoHandlers.ActiveDirectory)) { this.tracer.TraceDebug((long)this.GetHashCode(), "AD HANDLER: skipped by request."); result = response; } else if (response.Served) { this.tracer.TraceDebug((long)this.GetHashCode(), "AD HANDLER: skipped because photo has already been served by an upstream handler."); result = response; } else { response.ADHandlerProcessed = true; request.PerformanceLogger.Log("ADHandlerProcessed", string.Empty, 1U); try { result = this.FindTargetAndReadPhoto(request, response); } catch (ADNoSuchObjectException arg) { this.tracer.TraceDebug <ADNoSuchObjectException>((long)this.GetHashCode(), "AD HANDLER: no photo. Exception: {0}", arg); request.PerformanceLogger.Log("ADHandlerPhotoAvailable", string.Empty, 0U); result = response; } catch (TransientException arg2) { this.tracer.TraceError <TransientException>((long)this.GetHashCode(), "AD HANDLER: transient exception at reading photo. Exception: {0}", arg2); request.PerformanceLogger.Log("ADHandlerError", string.Empty, 1U); throw; } catch (ADOperationException arg3) { this.tracer.TraceError <ADOperationException>((long)this.GetHashCode(), "AD HANDLER: AD exception at reading photo. Exception: {0}", arg3); request.PerformanceLogger.Log("ADHandlerError", string.Empty, 1U); throw; } catch (IOException arg4) { this.tracer.TraceError <IOException>((long)this.GetHashCode(), "AD HANDLER: I/O exception at reading photo. Exception: {0}", arg4); request.PerformanceLogger.Log("ADHandlerError", string.Empty, 1U); throw; } } } } return(result); }
private PhotoResponse FindPersonAndServePhoto(PhotoRequest request, PhotoResponse response) { Person person = this.FindPerson(request); if (person == null) { this.tracer.TraceDebug((long)this.GetHashCode(), "PRIVATE HANDLER: person could not be found."); return(this.ServePhotoNotFound(response)); } return(this.ReadPhotoOffOfPersonAndServe(person, request, response)); }
private PhotoResponse ServePhotoNotModified(PhotoRequest request, PhotoResponse response) { this.tracer.TraceDebug <string>((long)this.GetHashCode(), "FILE SYSTEM HANDLER: NOT MODIFIED. Requestor already has photo cached. ETag: {0}", request.ETag); response.ServerCacheHit = true; response.Served = true; response.Status = HttpStatusCode.NotModified; response.IsPhotoFileOnFileSystem = true; request.PerformanceLogger.Log("FileSystemHandlerPhotoAvailable", string.Empty, 1U); request.PerformanceLogger.Log("FileSystemHandlerPhotoServed", string.Empty, 1U); return(response); }
private PhotoResponse SavePhotosToFileSystem(PhotoRequest request, PhotoResponse response) { response.FileSystemUploadHandlerProcessed = true; this.tracer.TraceDebug <string>((long)this.GetHashCode(), "File system photo upload handler: saving photos of {0} to file system.", request.TargetPrimarySmtpAddress); FileSystemPhotoMap map = new FileSystemPhotoMap(this.photosRootDirectoryFullPath, this.upstreamTracer); foreach (UserPhotoSize size in this.sizesToCacheOnFileSystem) { this.SavePhotoToFileSystem(request, response, map, size); } return(response); }
public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { ArgumentValidator.ThrowIfNull("request", request); ArgumentValidator.ThrowIfNull("response", response); PhotoResponse result; using (new StopwatchPerformanceTracker("PrivateHandlerTotal", request.PerformanceLogger)) { using (new StorePerformanceTracker("PrivateHandlerTotal", request.PerformanceLogger)) { if (request.ShouldSkipHandlers(PhotoHandlers.Private)) { this.tracer.TraceDebug((long)this.GetHashCode(), "PRIVATE HANDLER: skipped by request."); result = response; } else if (response.Served) { this.tracer.TraceDebug((long)this.GetHashCode(), "PRIVATE HANDLER: skipped because photo has already been served by an upstream handler."); result = response; } else if (request.RequestorMailboxSession == null) { this.tracer.TraceDebug((long)this.GetHashCode(), "PRIVATE HANDLER: skipped because a session to the requestor's mailbox has NOT been initialized."); result = response; } else { response.PrivateHandlerProcessed = true; request.PerformanceLogger.Log("PrivateHandlerProcessed", string.Empty, 1U); try { result = this.FindContactOrPersonAndServePhoto(request, response); } catch (ObjectNotFoundException arg) { this.tracer.TraceDebug <ObjectNotFoundException>((long)this.GetHashCode(), "PRIVATE HANDLER: photo not found. Exception: {0}", arg); result = response; } catch (StorageTransientException arg2) { this.tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "PRIVATE HANDLER: transient exception at reading photo. Exception: {0}", arg2); throw; } catch (StoragePermanentException arg3) { this.tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "PRIVATE HANDLER: permanent exception at reading photo. Exception: {0}", arg3); throw; } } } } return(result); }
private PhotoResponse ServePhotoWithRedirect(PhotoRequest request, PhotoResponse response, string photoUrl, StoreObjectId photoSourceContactId, string photoSourceNetworkId) { this.tracer.TraceDebug <string, StoreObjectId, string>((long)this.GetHashCode(), "PRIVATE HANDLER: serving photo at '{0}'; found in contact with ID: '{1}'; source network: '{2}'", photoUrl, photoSourceContactId, photoSourceNetworkId); response.Served = true; response.Status = HttpStatusCode.Found; response.PhotoUrl = photoUrl; response.HttpExpiresHeader = UserAgentPhotoExpiresHeader.Default.ComputeExpiresHeader(DateTime.UtcNow, HttpStatusCode.Found, this.configuration); response.Thumbprint = null; this.TraceInformationAboutContact(photoSourceContactId, request); request.PerformanceLogger.Log("PrivateHandlerServedRedirect", string.Empty, 1U); return(response); }
private int ComputeAndStampThumbprintOntoResponse(PhotoResponse response) { if (response.Thumbprint != null) { this.tracer.TraceDebug((long)this.GetHashCode(), "CACHING HANDLER: thumbprint has already been computed by upstream handler."); return(response.Thumbprint.Value); } this.tracer.TraceDebug((long)this.GetHashCode(), "CACHING HANDLER: thumbprint has NOT been computed by upstream handler. Computing now."); response.OutputPhotoStream.Seek(0L, SeekOrigin.Begin); int num = PhotoThumbprinter.Default.Compute(response.OutputPhotoStream); response.Thumbprint = new int?(num); return(num); }
// Token: 0x06001174 RID: 4468 RVA: 0x00048AC4 File Offset: 0x00046CC4 public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { if (request.Trace) { this.tracer.TraceDebug((long)this.GetHashCode(), "Diagnostics photo handler: skipped because request is already being traced."); return(response); } if (this.ShouldTraceRequest(response)) { request.Trace = true; this.tracer.TraceDebug((long)this.GetHashCode(), "Diagnostics photo handler: enabled tracing on this request."); } return(response); }
private PhotoResponse SavePhotoToAD(PhotoRequest request, PhotoResponse response) { byte[] photoToSaveToAD = this.GetPhotoToSaveToAD(response.UploadedPhotos); if (photoToSaveToAD == null || photoToSaveToAD.Length == 0) { this.tracer.TraceDebug((long)this.GetHashCode(), "AD photo upload handler: skipped because photo to save to AD is not available."); return(response); } response.ADUploadHandlerProcessed = true; using (MemoryStream memoryStream = new MemoryStream(photoToSaveToAD)) { this.writer.Write(request.UploadTo, memoryStream); } return(response); }
// Token: 0x060011DE RID: 4574 RVA: 0x0004B13C File Offset: 0x0004933C public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { PhotoResponse result; try { result = this.localServerPipeline.Retrieve(request, response); } catch (WrongServerException) { this.tracer.TraceDebug((long)this.GetHashCode(), "LOCAL SERVER WITH FALLBACK TO OTHER SERVER PIPELINE: target mailbox is NOT on this server. Falling back to other server."); result = this.FallbackToOtherServer(request, response); } return(result); }
public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { ArgumentValidator.ThrowIfNull("request", request); ArgumentValidator.ThrowIfNull("response", response); if (response.Served) { this.tracer.TraceDebug((long)this.GetHashCode(), "TARGET NOT FOUND HANDLER: skipped because photo has already been served by an upstream handler."); return(response); } this.tracer.TraceDebug((long)this.GetHashCode(), "TARGET NOT FOUND HANDLER: responding request with HTTP 404 Not Found."); response.TargetNotFoundHandlerProcessed = true; response.Served = true; response.Status = HttpStatusCode.NotFound; response.HttpExpiresHeader = UserAgentPhotoExpiresHeader.Default.ComputeExpiresHeader(DateTime.UtcNow, HttpStatusCode.NotFound, this.configuration); return(response); }
private int ReadThumbprintAndStampOntoResponse(PhotoRequest request, PhotoResponse response, string photoFullPath) { this.tracer.TraceDebug <string, string, UserPhotoSize>((long)this.GetHashCode(), "FILE SYSTEM HANDLER: reading thumbprint of photo file {0} for ({1}, {2})", photoFullPath, request.TargetSmtpAddress, request.Size); int result; using (new StopwatchPerformanceTracker("FileSystemHandlerReadThumbprint", request.PerformanceLogger)) { using (new CpuPerformanceTracker("FileSystemHandlerReadThumbprint", request.PerformanceLogger)) { int num = this.reader.ReadThumbprint(photoFullPath); response.Thumbprint = new int?(num); result = num; } } return(result); }
private void SavePhotoToFileSystem(PhotoRequest request, PhotoResponse response, FileSystemPhotoMap map, UserPhotoSize size) { byte[] uploadedPhotoOfSize = this.GetUploadedPhotoOfSize(response.UploadedPhotos, size); if (uploadedPhotoOfSize == null || uploadedPhotoOfSize.Length == 0) { this.tracer.TraceError <UserPhotoSize>((long)this.GetHashCode(), "File system photo upload handler: photo of size {0} NOT available and will NOT be saved to file system.", size); return; } string text = map.Map(request.TargetPrimarySmtpAddress, size); using (MemoryStream memoryStream = new MemoryStream(uploadedPhotoOfSize)) { this.tracer.TraceDebug <string>((long)this.GetHashCode(), "File system photo upload handler: writing photo at {0}", text); this.DeleteThenWritePhoto(text, response.Thumbprint.Value, memoryStream); } }
private void ComputeAndStampPhotoFullPathOntoResponse(PhotoRequest request, PhotoResponse response) { if (!string.IsNullOrEmpty(response.PhotoFullPathOnFileSystem)) { return; } string smtpAddressForCacheFilename = this.GetSmtpAddressForCacheFilename(request); if (string.IsNullOrEmpty(smtpAddressForCacheFilename)) { this.tracer.TraceDebug((long)this.GetHashCode(), "CACHING HANDLER: cannot compute SMTP address for cache filename."); return; } response.PhotoFullPathOnFileSystem = new FileSystemPhotoMap(this.photosRootDirectoryFullPath, this.tracer).Map(smtpAddressForCacheFilename, request.Size); this.tracer.TraceDebug <string>((long)this.GetHashCode(), "CACHING HANDLER: computed photo full path: {0}", response.PhotoFullPathOnFileSystem); }
public PhotoResponse Upload(PhotoRequest request, PhotoResponse response) { if (request.Preview) { return(response); } PhotoResponse result; try { switch (request.UploadCommand) { case UploadCommand.Upload: result = this.SavePhotosToFileSystem(request, response); break; case UploadCommand.Clear: result = this.ClearPhotosFromFileSystem(request, response); break; default: result = response; break; } } catch (CannotMapInvalidSmtpAddressToPhotoFileException arg) { this.tracer.TraceError <CannotMapInvalidSmtpAddressToPhotoFileException>((long)this.GetHashCode(), "File system photo upload handler: invalid SMTP address cannot be mapped to file system. Exception: {0}", arg); throw; } catch (IOException arg2) { this.tracer.TraceError <string, IOException>((long)this.GetHashCode(), "File system photo upload handler: failed to write photo for {0}. Exception: {1}", request.TargetPrimarySmtpAddress, arg2); result = response; } catch (UnauthorizedAccessException arg3) { this.tracer.TraceError <string, UnauthorizedAccessException>((long)this.GetHashCode(), "File system photo upload handler: authorization failure writing photo for {0}. Exception: {1}", request.TargetPrimarySmtpAddress, arg3); result = response; } catch (Win32Exception arg4) { this.tracer.TraceDebug <string, Win32Exception>((long)this.GetHashCode(), "File system photo upload handler: Win32 exception writing photo for {0}. Exception: {1}", request.TargetPrimarySmtpAddress, arg4); result = response; } return(result); }
// Token: 0x060011AB RID: 4523 RVA: 0x0004A628 File Offset: 0x00048828 private PhotoResponse ProcessResponseFromRemoteServer(PhotoRequest request, PhotoResponse response, HttpWebResponse httpResponse) { this.WriteTracesCollectedByRemoteServerOntoLocalTracer(httpResponse); HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode <= HttpStatusCode.NotModified) { if (statusCode == HttpStatusCode.OK || statusCode == HttpStatusCode.NotModified) { goto IL_78; } } else if (statusCode != HttpStatusCode.Unauthorized && statusCode == HttpStatusCode.NotFound) { goto IL_78; } this.tracer.TraceError <HttpStatusCode, string>((long)this.GetHashCode(), "HTTP HANDLER: request to remote service FAILED. Returning HTTP {0}: {1}", httpResponse.StatusCode, httpResponse.StatusDescription); response.Status = httpResponse.StatusCode; return(response); IL_78: using (new StopwatchPerformanceTracker("HttpHandlerGetAndReadResponseStream", request.PerformanceLogger)) { using (Stream responseStream = httpResponse.GetResponseStream()) { string text = httpResponse.Headers[HttpResponseHeader.ETag]; string text2 = httpResponse.Headers[HttpResponseHeader.Expires]; this.tracer.TraceDebug((long)this.GetHashCode(), "HTTP HANDLER: request to remote service was SUCCESSFUL. HTTP status: {0}; ETag: {1}; Content-Length: {2}; Content-Type: {3}; Expires: {4}", new object[] { httpResponse.StatusCode, text, httpResponse.ContentLength, httpResponse.ContentType, text2 }); responseStream.CopyTo(response.OutputPhotoStream); response.Served = true; response.ContentLength = httpResponse.ContentLength; response.ContentType = httpResponse.ContentType; response.Status = httpResponse.StatusCode; response.ETag = text; response.HttpExpiresHeader = text2; } } return(response); }
public PhotoResponse Retrieve(PhotoRequest request, PhotoResponse response) { ArgumentValidator.ThrowIfNull("request", request); ArgumentValidator.ThrowIfNull("response", response); if (!response.Served) { return(response); } response.OrganizationalToPrivateHandlerTransitionProcessed = true; HttpStatusCode status = response.Status; if (status <= HttpStatusCode.NotModified) { if (status != HttpStatusCode.OK) { switch (status) { case HttpStatusCode.Found: case HttpStatusCode.NotModified: break; case HttpStatusCode.SeeOther: goto IL_6C; default: goto IL_6C; } } return(response); } if (status != HttpStatusCode.NotFound && status != HttpStatusCode.InternalServerError) { } IL_6C: this.tracer.TraceDebug <HttpStatusCode>((long)this.GetHashCode(), "ORGANIZATIONAL to PRIVATE HANDLER TRANSITION: resetting response. Original status: {0}", response.Status); response.Served = false; response.Status = HttpStatusCode.NotFound; response.ContentLength = -1L; response.ContentType = null; response.Thumbprint = null; response.HttpExpiresHeader = string.Empty; response.PhotoUrl = string.Empty; response.ServerCacheHit = false; return(response); }
private PhotoResponse NegativeCacheToFileSystem(PhotoRequest request, PhotoResponse response) { using (new StopwatchPerformanceTracker("CachingHandlerCacheNegativePhoto", request.PerformanceLogger)) { using (new CpuPerformanceTracker("CachingHandlerCacheNegativePhoto", request.PerformanceLogger)) { response.CachingHandlerProcessed = true; request.PerformanceLogger.Log("CachingHandlerProcessed", string.Empty, 1U); int num = PhotoThumbprinter.Default.GenerateThumbprintForNegativeCache(); this.tracer.TraceDebug <string, int>((long)this.GetHashCode(), "CACHING HANDLER: caching NEGATIVE photo at {0} with thumbprint = {1:X8}", response.PhotoFullPathOnFileSystem, num); this.writer.Write(response.PhotoFullPathOnFileSystem, num, Stream.Null); response.PhotoWrittenToFileSystem = true; this.tracer.TraceDebug((long)this.GetHashCode(), "CACHING HANDLER: wrote NEGATIVE cache photo file."); response.Thumbprint = new int?(num); } } return(response); }
// Token: 0x06001342 RID: 4930 RVA: 0x0004F714 File Offset: 0x0004D914 public PhotoResponse Upload(PhotoRequest request, PhotoResponse response) { switch (request.UploadCommand) { case UploadCommand.Upload: if (request.Preview) { return(this.UploadPreview(request, response)); } return(this.LoadPreview(request, response)); case UploadCommand.Clear: return(this.ClearPreview(request, response)); default: return(response); } }
// Token: 0x0600114D RID: 4429 RVA: 0x00047BA8 File Offset: 0x00045DA8 private PhotoResponse ReadPhotoOntoResponse(PhotoRequest request, PhotoResponse response) { using (new StopwatchPerformanceTracker("ADHandlerReadPhoto", request.PerformanceLogger)) { using (new ADPerformanceTracker("ADHandlerReadPhoto", request.PerformanceLogger)) { PhotoMetadata photoMetadata = this.reader.Read(this.recipientSession, request.TargetAdObjectId, response.OutputPhotoStream); response.Served = true; response.Status = HttpStatusCode.OK; response.ContentLength = photoMetadata.Length; response.ContentType = photoMetadata.ContentType; response.Thumbprint = null; request.PerformanceLogger.Log("ADHandlerPhotoAvailable", string.Empty, 1U); request.PerformanceLogger.Log("ADHandlerPhotoServed", string.Empty, 1U); } } return(response); }
// Token: 0x06001208 RID: 4616 RVA: 0x0004C380 File Offset: 0x0004A580 public PhotoResponse Upload(PhotoRequest request, PhotoResponse response) { if (request.Preview) { return(response); } PhotoResponse result; try { switch (request.UploadCommand) { case UploadCommand.Upload: result = this.SavePhotoToMailbox(request, response); break; case UploadCommand.Clear: result = this.ClearPhotoFromMailbox(request, response); break; default: result = response; break; } } catch (ObjectNotFoundException arg) { this.tracer.TraceDebug <ObjectNotFoundException>((long)this.GetHashCode(), "Mailbox photo upload handler: photo not found. Exception: {0}", arg); throw; } catch (StorageTransientException arg2) { this.tracer.TraceError <StorageTransientException>((long)this.GetHashCode(), "Mailbox photo upload handler: transient exception saving or clearing photo. Exception: {0}", arg2); throw; } catch (StoragePermanentException arg3) { this.tracer.TraceError <StoragePermanentException>((long)this.GetHashCode(), "Mailbox photo upload handler: permanent exception saving or clearing photo. Exception: {0}", arg3); throw; } return(result); }