/// <summary>
/// set http response cookies
/// </summary>
/// <param name="response"></param>
/// <param name="companyUserSesson">if null-remove cookie</param>
public void SetResponse ( HttpResponseBase response , CompanyUserSession companyUserSesson )
{
if (companyUserSesson != null)
{
if (response.Cookies[SessionIdCookieName] == null)
{
HttpCookie sidCookie = new HttpCookie(SessionIdCookieName, companyUserSesson.Sid);
response.Cookies.Add(sidCookie);
}
else
{
response.Cookies[SessionIdCookieName].Value = companyUserSesson.Sid;
}
if (response.Cookies[UserIdCookieName] == null)
{
HttpCookie uIdCookie = new HttpCookie(UserIdCookieName, companyUserSesson.CompanyUserId.ToString());
response.Cookies.Add(uIdCookie);
}
else
{
response.Cookies[UserIdCookieName].Value = companyUserSesson.CompanyUserId.ToString();
}
}
else
{
HttpCookie uIdCookie = new HttpCookie(UserIdCookieName, "") {Expires = DateTime.Now};
response.Cookies.Add ( uIdCookie );
HttpCookie sidCookie = new HttpCookie(SessionIdCookieName, "") {Expires = DateTime.Now};
response.Cookies.Add ( sidCookie );
}
}
public bool HandleResult( IResult result, IFormatInfo outputFormat, HttpRequestBase request, HttpResponseBase response )
{
response.AddHeader("Accept-Ranges", "bytes");
Range range;
if ( !TryGetRequestedRange( request, out range ) )
{
return false;
}
if (!ValidateIfRangeHeader(request, result))
{
return false;
}
var offset = range.Start ?? 0;
var end = range.End.HasValue ? range.End.Value : result.ContentLength - 1;
var length = end - offset + 1;
response.AddHeader( "Content-Range", "bytes " + offset + "-" + end + "/" + result.ContentLength );
response.StatusCode = 206;
result.Serve( response, offset, length );
return true;
}
protected override void Context()
{
AccountService = MockRepository.GenerateStub<IAccountService>();
Identity = new FakeIdentity(Username);
_user = new FakePrincipal(Identity, null);
HttpRequest = MockRepository.GenerateStub<HttpRequestBase>();
HttpContext = MockRepository.GenerateStub<HttpContextBase>();
HttpContext.Stub(x => x.Request).Return(HttpRequest);
HttpContext.User = _user;
_httpResponse = MockRepository.GenerateStub<HttpResponseBase>();
_httpResponse.Stub(x => x.Cookies).Return(new HttpCookieCollection());
HttpContext.Stub(x => x.Response).Return(_httpResponse);
Logger = MockRepository.GenerateStub<ILogger>();
WebAuthenticationService = MockRepository.GenerateStub<IWebAuthenticationService>();
MappingEngine = MockRepository.GenerateStub<IMappingEngine>();
AccountCreator = MockRepository.GenerateStub<IAccountCreator>();
AccountController = new AccountController(AccountService, Logger, WebAuthenticationService, MappingEngine, null, AccountCreator);
AccountController.ControllerContext = new ControllerContext(HttpContext, new RouteData(), AccountController);
}
public ResponseCaptureHelper(HttpResponseBase response)
{
_response = response;
_originalWriter = response.Output;
_localWriter = new StringWriter();
response.Output = _localWriter;
}
// Adds do-not-cache headers to the specified HTTP response (which is expected to result in a file-save
// operation by the browser) in such a way that the IE browser is still able to save the file.
// (TODO: if we have more file-save action results than just CsvActionResult, this method can be lifted to
// a common location and be used by all of them.)
private static void AddDoNotCacheHeadersToFileSaveResponse(HttpResponseBase response, HttpRequestBase request)
{
// Get the browser's internal identifier (from .NET browser definition file).
var browserId = request.Browser.Id;
// Detect if the browser is a problem version of IE (= IE 7 and 8; IE 6 and lower aren't supported by this
// website).
var problemIEVersion = false;
if ((browserId.Equals("IE7", StringComparison.OrdinalIgnoreCase)) ||
(browserId.Equals("IE8", StringComparison.OrdinalIgnoreCase)))
{
problemIEVersion = true;
}
// Add do-not-cache response headers.
if (!problemIEVersion)
{
// Add the website's standard do-not-cache headers.
NoCacheAttribute.AddResponseHeaders(response);
}
else
{
// For problem IE versions... reference: http://stackoverflow.com/a/5084395
response.AppendHeader("Last-Modified",
DateTime.UtcNow.ToString("R", CultureInfo.InvariantCulture)); // RFC 1123 format
response.AppendHeader("Expires", "-1");
response.AppendHeader("Cache-Control", "must-revalidate, private");
response.AppendHeader("Vary", "*");
}
}
public BootStrapModal(HttpResponseBase httpResponse)
{
if (httpResponse == null)
throw new ArgumentNullException("httpResponse");
this._writer = httpResponse.Output;
}
/// <summary>
/// Sets the cache headers for the HTTP response given <see cref="settings" />.
/// </summary>
/// <param name="response">The HTTP response.</param>
/// <param name="settings">The cache settings.</param>
public void SetCacheHeaders(HttpResponseBase response, CacheSettings settings)
{
var cacheability = HttpCacheability.NoCache;
switch (settings.Location)
{
case OutputCacheLocation.Any:
case OutputCacheLocation.Downstream:
cacheability = HttpCacheability.Public;
break;
case OutputCacheLocation.Client:
case OutputCacheLocation.ServerAndClient:
cacheability = HttpCacheability.Private;
break;
}
response.Cache.SetCacheability(cacheability);
if (cacheability != HttpCacheability.NoCache)
{
response.Cache.SetExpires(DateTime.Now.AddSeconds(settings.Duration));
response.Cache.SetMaxAge(new TimeSpan(0, 0, settings.Duration));
}
if (settings.NoStore)
{
response.Cache.SetNoStore();
}
}
public void SendHeaders(HttpResponseBase response, ResponseCompressionType compressionType, IEntity entity)
{
//Data must be in uncompressed format when responding partially
if (entity.CompressionType != ResponseCompressionType.None)
{
//TODO: perhaps we could uncompress object, but for now we don't worry about it
throw new Exception("Cannot do a partial response on compressed data");
}
HttpResponseHeaderHelper.SetContentEncoding(response, compressionType);
switch (compressionType)
{
case ResponseCompressionType.None:
var contentLength = Range.EndRange - Range.StartRange + 1;
HttpResponseHeaderHelper.AppendHeader(response, HttpHeaderContentLength, contentLength.ToString());
break;
case ResponseCompressionType.GZip:
response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
//This means that the output stream will be chunked, so we don't have to worry about content length
break;
case ResponseCompressionType.Deflate:
response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
//This means that the output stream will be chunked, so we don't have to worry about content length
break;
}
response.ContentType = entity.ContentType;
HttpResponseHeaderHelper.AppendHeader(response, HttpHeaderContentRange, Bytes + " " + Range.StartRange + "-" + Range.EndRange + "/" + entity.ContentLength);
}
/// <summary>
/// Prepares the excel.
/// </summary>
/// <param name="dataTable">The data table.</param>
/// <param name="reportName">Name of the report.</param>
/// <param name="reportTitle">The report title.</param>
/// <param name="responseBase">The response base.</param>
/// <param name="serverBase">The server base.</param>
public void PrepareExcel(DataTable dataTable, string reportName, string reportTitle, HttpResponseBase responseBase, HttpServerUtilityBase serverBase)
{
this.response = responseBase;
this.server = serverBase;
this.GenerateTable(dataTable, reportName, reportTitle);
}
protected override void WriteFile(HttpResponseBase response)
{
using (XmlWriter writer = XmlWriter.Create(response.OutputStream))
{
_Feed.GetRss20Formatter().WriteTo(writer);
}
}
private static void SetCookie(HttpResponseBase response, string language)
{
response.Cookies.Add(new HttpCookie(CookieName, language)
{
Expires = DateTime.Now.AddYears(1),
});
}
public static Dictionary<string, string> GetFavs(HttpResponseBase Response)
{
Dictionary<string, string> favs = new Dictionary<string, string>();
HttpCookie testCookie = new HttpCookie("favorites");
testCookie.Expires = DateTime.Now.AddHours(24);
testCookie.Name = "favorites";
testCookie.Values.Add("linkText", "linkUrl");
testCookie.Values.Add("linkText2", "linkUrl2");
Response.Cookies.Add(testCookie);
System.Web.HttpCookie cookieFavs = Response.Cookies.Get("favorites");
if (cookieFavs.Values.Count > 0)
{
NameValueCollection nvc = cookieFavs.Values;
for (int i = 0; i < nvc.Count; i++ )
{
string key = nvc.Keys[i];
string value = nvc[i];
favs.Add(Resources.Localizer.GetString("Resources.Shared.Nav", key, key), value);
}
}
else // get from db
{
}
return favs;
}
/// <summary>
/// Prepares the excel.
/// </summary>
/// <param name="dataSet">The data set.</param>
/// <param name="reportName">Name of the report.</param>
/// <param name="reportTitle">The report title.</param>
/// <param name="responseBase">The response base.</param>
/// <param name="serverBase">The server base.</param>
/// <param name="voyageIds">The voyage ids.</param>
public void PrepareExcel(DataSet dataSet, string reportName, string reportTitle, HttpResponseBase responseBase, HttpServerUtilityBase serverBase, string voyageIds)
{
this.response = responseBase;
this.server = serverBase;
this.GenerateGuestReconciliationTable(dataSet, reportName, reportTitle, voyageIds);
}
public virtual void Execute(HttpResponseBase response)
{
response.StatusCode = 200;
response.ContentType = "text/html";
var masterControls = new List<IControlPanelControl>();
masterControls.AddRange(CreateHeaderControls(_securityState));
masterControls.AddRange(_controls);
masterControls.AddRange(CreateFooterControls());
using (var writer = new HtmlTextWriter(response.Output))
{
// this securitydisabler allows the control panel to execute unfettered when debug compilation is enabled but you are not signed into Sitecore
using (new SecurityDisabler())
{
foreach (var control in masterControls)
control.Render(writer);
}
}
response.End();
}
public PlaceholderReplacingResponseFilter(HttpResponseBase response, IPlaceholderTracker placeholderTracker)
{
this.response = response;
this.placeholderTracker = placeholderTracker;
outputStream = response.Filter;
htmlBuffer = new StringBuilder();
}
void CacheLongTime(HttpResponseBase response, string actualETag)
{
response.Cache.SetCacheability(HttpCacheability.Public);
response.Cache.SetExpires(DateTime.UtcNow.AddYears(1));
response.Cache.SetMaxAge(new TimeSpan(365, 0, 0, 0));
response.Cache.SetETag(actualETag);
}
public void Apply(HttpResponseBase response)
{
if(response == null)
{
throw new ArgumentException("response can't be null");
}
response.Cache.SetCacheability(Cacheability);
if (HttpStatusCode == HttpStatusCode.SeeOther || Location != null)
{
if (Location == null)
{
throw new InvalidOperationException("Missing Location on redirect.");
}
if (HttpStatusCode != HttpStatusCode.SeeOther)
{
throw new InvalidOperationException("Invalid HttpStatusCode for redirect, but Location is specified");
}
response.Redirect(Location.ToString());
}
response.StatusCode = (int)HttpStatusCode;
}
protected override void DoAction(HttpResponseBase response, HttpContextBase context)
{
var trigger = context.Request.Params["trigger"];
var jobGroup = context.Request.Params["group"];
_schedulerProvider.Scheduler.ResumeTrigger(new TriggerKey(trigger, jobGroup));
}
public static void ChooseSuitableCompression(NameValueCollection requestHeaders, HttpResponseBase response)
{
if (requestHeaders == null) throw new ArgumentNullException(nameof(requestHeaders));
if (response == null) throw new ArgumentNullException(nameof(response));
/// load encodings from header
QValueList encodings = new QValueList(requestHeaders[ACCEPT_ENCODING_HEADER]);
/// get the types we can handle, can be accepted and
/// in the defined client preference
QValue preferred = encodings.FindPreferred("gzip", "deflate", "identity");
/// if none of the preferred values were found, but the
/// client can accept wildcard encodings, we'll default
/// to Gzip.
if (preferred.IsEmpty && encodings.AcceptWildcard && encodings.Find("gzip").IsEmpty)
preferred = new QValue("gzip");
// handle the preferred encoding
switch (preferred.Name)
{
case "gzip":
response.AppendHeader(CONTENT_ENCODING_HEADER, "gzip");
response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
break;
case "deflate":
response.AppendHeader(CONTENT_ENCODING_HEADER, "deflate");
response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
break;
case "identity":
default:
break;
}
}
public XrcResponse(Stream stream, HttpResponseBase parentResponse = null)
{
if (stream == null)
throw new ArgumentNullException("stream");
_innerResponse = parentResponse;
_isStreamOwner = true;
if (_innerResponse == null)
{
_cookies = new HttpCookieCollection();
_statusCode = (int)HttpStatusCode.OK;
_contentEncoding = Encoding.UTF8;
_contentType = "text/html; charset=UTF-8";
_redirectLocation = null;
_statusDescription = null;
_outputStream = stream;
_output = new StreamWriter(stream, _contentEncoding);
}
else
{
_cookies = _innerResponse.Cookies;
_statusCode = (int)HttpStatusCode.OK;
_contentEncoding = _innerResponse.ContentEncoding;
_contentType = _innerResponse.ContentType;
_redirectLocation = null;
_statusDescription = null;
_outputStream = stream;
_output = new StreamWriter(stream, _contentEncoding);
}
}
public static void Restore(HttpRequestBase request, HttpResponseBase response)
{
string serverHash = request.QueryString[queryStringName];
if (serverHash != null)
{
string cookieHeader = request.Headers["Cookie"];
string cookieValue = cookieName + "=" + serverHash;
// Modifying request.Cookies doesn't work
if (cookieHeader != null)
{
if (cookieHeader.Contains(cookieName + "="))
{
cookieHeader = regex.Replace(cookieHeader, cookieValue + ";");
}
else
{
cookieHeader += "; " + cookieValue;
}
request.Headers["Cookie"] = cookieHeader;
}
else
{
request.Headers.Add("Cookie", cookieValue);
}
// response.Cookies also updates request.Cookies, which may have other implications, so we set the raw cookie
response.Headers.Add("Set-Cookie", cookieName + "=" + serverHash + ";Path=" + request.ApplicationPath + ";Domain=" + request.Url.Host);
}
}
protected override void WriteFile(HttpResponseBase response)
{
using (XmlWriter writer = XmlWriter.Create(response.OutputStream))
{
_feed.SaveAsRss20(writer);
}
}
public static bool IsFileFromCache(FileInfo info, HttpRequestBase request, HttpResponseBase response)
{
DateTime updated = info.LastWriteTimeUtc;
string filename = info.Name;
DateTime modifyDate;
if (!DateTime.TryParse(request.Headers["If-Modified-Since"], out modifyDate))
{
modifyDate = DateTime.UtcNow;
}
string eTag = GetFileETag(filename, updated);
if (!IsFileModified(updated, eTag, request))
{
response.StatusCode = (int)System.Net.HttpStatusCode.NotModified;
response.StatusDescription = "Not Modified";
response.AddHeader("Content-Length", "0");
response.Cache.SetCacheability(HttpCacheability.Public);
response.Cache.SetLastModified(updated);
response.Cache.SetETag(eTag);
return true;
}
else
{
response.Cache.SetAllowResponseInBrowserHistory(true);
response.Cache.SetCacheability(HttpCacheability.Public);
response.Cache.SetLastModified(updated);
response.Cache.SetETag(eTag);
return false;
}
}
protected virtual void SerializeData(HttpResponseBase response)
{
if (ErrorMessages.Any())
{
var originalData = Data;
Data = new
{
Success = false,
OriginalData = originalData,
ErrorMessage = string.Join("\n", ErrorMessages),
ErrorMessages = ErrorMessages.ToArray()
};
response.StatusCode = StatusCode;
}
var settings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
Converters = new JsonConverter[]
{
new StringEnumConverter(),
},
};
response.Write(JsonConvert.SerializeObject(Data, settings));
}
void SendAsset(HttpRequestBase request, HttpResponseBase response, Bundle bundle, IAsset asset)
{
response.ContentType = bundle.ContentType;
var actualETag = "\"" + asset.Hash.ToHexString() + "\"";
if(request.RawUrl.Contains(asset.Hash.ToHexString())) {
CacheLongTime(response, actualETag);
}
else {
NoCache(response);
}
var givenETag = request.Headers["If-None-Match"];
if (!disableHashCheck && givenETag == actualETag)
{
SendNotModified(response);
}
else
{
using (var stream = asset.OpenStream())
{
stream.CopyTo(response.OutputStream);
}
}
}
internal static string BuildManifestResponse(HttpResponseBase Response, TylerUI.AppCacheModel model)
{
Response.ContentType = "text/cache-manifest";
Response.Cache.SetCacheability(HttpCacheability.NoCache);
Response.Cache.SetExpires(DateTime.MinValue);
//mvc is adding a blank line on the page, so don't use cshtml for this, just build a string
//return View("~/Views/Shared/_TylerUiAppManifest.cshtml", model);
var sb = new StringBuilder();
sb.AppendLine("CACHE MANIFEST");
sb.AppendLine(String.Empty);
sb.Append("# Server Assembly Version: ");
sb.AppendLine(model.AssemblyVersion);
sb.AppendLine(String.Empty);
sb.AppendLine("NETWORK:");
sb.AppendLine("*");
sb.AppendLine(String.Empty);
sb.AppendLine("CACHE:");
foreach (string cacheItem in model.CacheCollection)
{
sb.AppendLine(cacheItem);
}
return sb.ToString();
}
protected override void DoAction(HttpResponseBase response, HttpContextBase context)
{
var jobName = context.Request.Params["job"];
var jobGroup = context.Request.Params["group"];
_schedulerProvider.Scheduler.PauseJob(new JobKey(jobName, jobGroup));
}
public void FillResponse(HttpResponseBase response, HttpContextBase context)
{
var trigger = context.Request.Params["trigger"];
var jobGroup = context.Request.Params["group"];
_schedulerProvider.Scheduler.PauseTrigger(trigger, jobGroup);
response.Redirect(context.Request.UrlReferrer.OriginalString);
}
public static void SavePreferredCulture(HttpResponseBase response, String language,
Int32 expireDays = 1)
{
var cookie = new HttpCookie(CookieName) { Expires = DateTime.Now.AddDays(expireDays) };
cookie.Values[CookieLangEntry] = language;
response.Cookies.Add(cookie);
}
public void Apply(HttpResponseBase response)
{
if(response == null)
{
throw new ArgumentNullException("response");
}
response.Cache.SetCacheability(Cacheability);
if (HttpStatusCode == HttpStatusCode.SeeOther || Location != null)
{
if (Location == null)
{
throw new InvalidOperationException("Missing Location on redirect.");
}
if (HttpStatusCode != HttpStatusCode.SeeOther)
{
throw new InvalidOperationException("Invalid HttpStatusCode for redirect, but Location is specified");
}
response.Redirect(Location.ToString());
}
else
{
response.StatusCode = (int)HttpStatusCode;
response.ContentType = ContentType;
response.Write(Content);
response.End();
}
}
public static void ClearCookie(System.Web.HttpResponseBase response, string cookieName, string cookieValue)
{
if (response.Cookies.AllKeys.Contains(cookieName))
{
response.Cookies[cookieName].Value = cookieValue;
response.Cookies[cookieName].Expires = DateTime.UtcNow.AddDays(-1);
}
}
protected override void WriteFile(System.Web.HttpResponseBase response)
{
if (fileContents == null)
{
throw new ArgumentNullException("fileContents");
}
response.OutputStream.Write(this.fileContents, 0, this.fileContents.Length);
}
/// <summary>
/// Write exception to output message
/// </summary>
public async Task WriteExceptionAsync(HttpResponse httpResponse, Exception ex)
{
var webx = WebSyncException.GetWebSyncException(ex);
var webXMessage = JsonConvert.SerializeObject(webx);
httpResponse.StatusCode = StatusCodes.Status400BadRequest;
httpResponse.ContentLength = webXMessage.Length;
await httpResponse.WriteAsync(webXMessage);
}
public static void SetCookie(this System.Web.HttpResponseBase response, string name, string value, DateTime?expires = null, string path = "/")
{
var cookie = new System.Web.HttpCookie(name, value);
if (expires.HasValue)
{
cookie.Expires = expires.Value;
}
cookie.Path = path;
response.SetCookie(cookie);
}
public static void UpdateCookie(System.Web.HttpResponseBase response, string cookieName, string cookieValue)
{
if (response.Cookies.AllKeys.Contains(cookieName))
{
response.Cookies[cookieName].Value = cookieValue;
}
else
{
response.Cookies.Add(new HttpCookie(cookieName, cookieValue));
}
}
public override void ExecuteResult(ControllerContext context)
{
System.Web.HttpResponseBase response = context.HttpContext.Response;
System.Web.HttpRequestBase request = context.HttpContext.Request;
string url = request.Url.OriginalString;
ViewData["RequestedUrl"] = url;
ViewData["ReferrerUrl"] = (request.UrlReferrer != null && request.UrlReferrer.OriginalString != url) ? request.UrlReferrer.OriginalString : null;
response.StatusCode = 404;
// Prevent IIS7 from overwriting our error page!
response.TrySkipIisCustomErrors = true;
base.ExecuteResult(context);
}
/// <summary>
/// Write exception to output message
/// </summary>
public async Task WriteExceptionAsync(HttpResponse httpResponse, Exception ex)
{
// Check if it's an unknwon error, not managed (yet)
if (!(ex is SyncException syncException))
{
syncException = new SyncException(ex.Message, SyncStage.None, this.LocalProvider.ProviderTypeName, SyncExceptionType.Unknown);
}
var webXMessage = JsonConvert.SerializeObject(syncException);
httpResponse.StatusCode = StatusCodes.Status400BadRequest;
httpResponse.ContentLength = webXMessage.Length;
await httpResponse.WriteAsync(webXMessage);
}
public void Logout(HttpRequestBase request, System.Web.HttpResponseBase response, System.Web.HttpSessionStateBase session)
{
//HttpCookie myCookie = new HttpCookie("rfs.username");
//myCookie = Request.Cookies["rfs.username"];
//if (myCookie != null)
//{
// Session[myCookie.Value] = "";
//}
//HttpCookie currentUserCookie = Request.Cookies["rfs.username"];
//Response.Cookies.Remove("rfs.username");
//if (currentUserCookie != null)
//{
// currentUserCookie.Expires = DateTime.Now.AddDays(-10);
// currentUserCookie.Value = null;
// Response.SetCookie(currentUserCookie);
//}
}
public void Logout(System.Web.HttpRequestBase request, System.Web.HttpResponseBase response, System.Web.HttpSessionStateBase session)
{
HttpCookie myCookie = new HttpCookie("rfs.username");
myCookie = request.Cookies["rfs.username"];
if (myCookie != null)
{
session[myCookie.Value] = "";
}
HttpCookie currentUserCookie = request.Cookies["rfs.username"];
response.Cookies.Remove("rfs.username");
if (currentUserCookie != null)
{
currentUserCookie.Expires = DateTime.Now.AddDays(-10);
currentUserCookie.Value = null;
response.SetCookie(currentUserCookie);
}
}
protected override void WriteFile(System.Web.HttpResponseBase response)
{
iCalendar iCal = new iCalendar();
var evnt = iCal.Create <Event>();
evnt.Summary = _info.Name;
evnt.Start = new iCalDateTime(_info.StartDate);
evnt.Duration = _info.Duration;
evnt.GeographicLocation = _info.Geo;
evnt.Location = _info.Location;
evnt.Url = new Uri(_info.Url);
//iCal.Events.Add(evnt);
var ser = new iCalendarSerializer();
string result = ser.SerializeToString(iCal);
//iCalendarSerializer serializer = new iCalendarSerializer(iCal);
//string result = serializer.SerializeToString();
response.ContentEncoding = Encoding.UTF8;
response.Write(result);
}
/// <summary>
/// 输出JS文本到客户端
public static void WriteJavaScript(this HttpResponseBase Response, JavaScript script)
{
Response.ContentType = "text/html";
Response.ContentEncoding = Encoding.UTF8;
Response.Write(script.ToString());
}
/// <summary>
/// Writes the file to the response.
/// </summary>
/// <param name="response">The response object.</param>
protected override void WriteFile(System.Web.HttpResponseBase response)
{
this.Content(response.OutputStream);
}
public static Stream GetBody(this HttpResponse r)
{
return(r.Body);
}
protected override void WriteFile(System.Web.HttpResponseBase response)
{
}
public void SignIn(int adminId, string userName, string firstName, string lastName, bool isSystemUser, System.Web.HttpResponseBase httpResponseBase)
{
AdminData adminData = new AdminData
{
AdminId = adminId,
UserName = userName,
LastName = lastName,
FirstName = firstName,
IsSystemUser = isSystemUser
};
string encodedTicket = FormsAuthentication.Encrypt(
new FormsAuthenticationTicket(
version: 1,
name: userName,
issueDate: DateTime.UtcNow,
expiration: DateTime.UtcNow.Add(FormsAuthentication.Timeout),
isPersistent: true,
userData: adminData.ToString())
);
HttpCookie httpCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encodedTicket);
httpResponseBase.Cookies.Add(httpCookie);
}
/// <summary>
/// Writes the file to the response.
/// </summary>
/// <param name="response">The response object.</param>
protected override void WriteFile(System.Web.HttpResponseBase response)
{
response.Buffer = bufferOutput;
content(response.OutputStream);
}
/// <summary>
/// Redirects the specified response.
/// </summary>
/// <param name="response">The response.</param>
/// <param name="responseCode">The response code.</param>
/// <param name="url">The URL.</param>
public static void Redirect(this HttpResponseBase response, int responseCode, string url)
{
Redirect(HttpContext.Current.Response, responseCode, url);
}
private void Init(NetHttpRequest request, NetHttpResponse response)
{
_request = request;
_response = response;
_utcTimestamp = DateTime.UtcNow;
}