public static void WriteValueString(WritableBuffer buffer, string value, HeaderOptions options)
{
switch (options & HeaderOptions.ValueCompressionMask)
{
case HeaderOptions.ValueCompressionAutomatic:
var len = HuffmanCode.GetByteCount(value);
if (len < value.Length)
{
WriteUInt32(buffer, (uint)len, 0x80, 7);
HuffmanCode.Write(buffer, value);
}
else
{
WriteUInt32(buffer, (uint)value.Length, 0, 7);
buffer.WriteAsciiString(value);
}
break;
case HeaderOptions.ValueCompressionOn:
len = HuffmanCode.GetByteCount(value);
WriteUInt32(buffer, (uint)len, 0x80, 7);
HuffmanCode.Write(buffer, value);
break;
case HeaderOptions.ValueCompressionOff:
WriteUInt32(buffer, (uint)value.Length, 0, 7);
buffer.WriteAsciiString(value);
break;
default:
throw new InvalidOperationException("Invalid value compression: " + options);
}
}
internal LayoutOptions toAPILayoutOptions()
{
TitleBarOptions titleBarOptions = new TitleBarOptions();
if (showTitle != null)
{
titleBarOptions.Title = showTitle.Value;
}
if (progressBar != null)
{
titleBarOptions.ProgressBar = progressBar.Value;
}
HeaderOptions headerOptions = new HeaderOptions();
if (breadCrumbs != null)
{
headerOptions.Breadcrumbs = breadCrumbs.Value;
}
if (sessionBar != null)
{
headerOptions.SessionBar = sessionBar.Value;
}
if (globalNavigation != null)
{
headerOptions.GlobalNavigation = globalNavigation.Value;
}
if (titleBarOptions != null)
{
headerOptions.TitleBar = titleBarOptions;
}
BrandingBarOptions brandingBarOptions = null;
if (logoImageLink != null || logoImageSource != null)
{
brandingBarOptions = new BrandingBarOptions();
Image logo = new Image();
logo.Link = logoImageLink;
logo.Src = logoImageSource;
brandingBarOptions.Logo = logo;
}
LayoutOptions result = new LayoutOptions();
if (iFrame != null)
{
result.Iframe = iFrame.Value;
}
if (navigator != null)
{
result.Navigator = navigator.Value;
}
result.Footer = new FooterOptions();
result.Header = headerOptions;
result.BrandingBar = brandingBarOptions;
return(result);
}
public void Init(List <Bank> Prg, List <Bank> Chr, HeaderOptions headerOpts)
{
Prg.Add(new Bank(0, MemorySizes.KB_32, 0x8000, true));
Chr.Add(new Bank(0, MemorySizes.KB_8, 0, true));
headerOpts.PrgRomBanks = 2;
headerOpts.ChrRomBanks = 1;
headerOpts.Mirroring = _mirroring;
}
/// <summary>
/// Initializes a new instance of the <see cref="AbstractFileParser" /> class.
/// </summary>
/// <param name="filePath">The file path.</param>
/// <param name="headerOption">The header option.</param>
/// <param name="hasFooter">If set to <c>true</c> then the file has a footer.</param>
/// <param name="shouldReturnDataCollection">If set to <c>true</c> then return a data collection.</param>
/// <param name="delimiter">The delimiter.</param>
public AbstractFileParser(string filePath, HeaderOptions headerOption, bool hasFooter, bool shouldReturnDataCollection, char?delimiter = null)
{
this.filePath = filePath;
this.hasFooter = hasFooter;
this.headerOption = headerOption;
this.ErrorHandling = ErrorOptions.OnErrorHalt;
this.shouldReturnDataCollection = shouldReturnDataCollection;
this.delimiter = delimiter;
}
public void Init(List <Bank> Prg, List <Bank> Chr, HeaderOptions headerOpts)
{
U8 i;
for (i = 0; i < 31; i++)
{
Prg.Add(new Bank(i, MemorySizes.KB_16, 0x8000));
}
Prg.Add(new Bank(++i, MemorySizes.KB_16, 0xC000, true));
headerOpts.PrgRomBanks = 32;
headerOpts.ChrRomBanks = 0;
//headerOpts.MapperControlledMirroring: 00001001 = 4 screen
}
private static void ApplyHeader(HeaderOptions obj)
{
var value = "";
switch (obj.FrameOption) {
case 1:
value = "DENY";
break;
case 2:
value = "SAMEORIGIN";
break;
default:
value = DetermineValue(obj.Origins, obj.RequestUri);
break;
}
obj.Response.Headers[HeaderConstants.XFrameOptions] = value;
}
public static Func <Func <IDictionary <string, object>, Task>, Func <IDictionary <string, object>, Task> > AntiClickjackingHeader(int option, params Uri[] origins)
{
return(next =>
env => {
var context = env.AsContext();
var response = context.Response;
var options = new HeaderOptions {
FrameOption = option,
Origins = origins,
Response = response,
RequestUri = context.Request.Uri
};
response.OnSendingHeaders(ApplyHeader, options);
return next(env);
});
}
public static Func<Func<IDictionary<string, object>, Task>, Func<IDictionary<string, object>, Task>> AntiClickjackingHeader(int option, params Uri[] origins)
{
return next =>
env => {
var context = env.AsContext();
var response = context.Response;
var options = new HeaderOptions {
FrameOption = option,
Origins = origins,
Response = response,
RequestUri = context.Request.Uri
};
response.OnSendingHeaders(ApplyHeader, options);
return next(env);
};
}
private HttpClient createInstanceAndHeadder(HeaderOptions headerOptions = default(HeaderOptions))
{
var webProxy = WebProxy.GetDefaultProxy();
webProxy.UseDefaultCredentials = true;
WebRequest.DefaultWebProxy = webProxy;
var handler = new HttpClientHandler()
{
UseDefaultCredentials = true,
Proxy = webProxy,
};
HttpClient client = client = new HttpClient(handler);
//client.DefaultRequestHeaders.Add("X-UserName", "System");
//client.DefaultRequestHeaders.Add("X-UserId", "System");
//client.DefaultRequestHeaders.Add("X-Password", "nextscape");
if (/*headerOptions.Has(HeaderOptions.OwinToken) &&*/ !string.IsNullOrEmpty(Token))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", Token);
client.DefaultRequestHeaders.Add("SourceID", TyrionBankerConfiguration.SourceId);
}
//if (headerOptions.Has(HeaderOptions.TimeOut))
//{
// double TimeOutInMinutes;
// if (!double.TryParse(ConfigurationManager.AppSettings["UploadTimeout"], out TimeOutInMinutes))
// {
// TimeOutInMinutes = 15;
// }
// client.Timeout = TimeSpan.FromMinutes(TimeOutInMinutes);
//}
//else
//{
// double DefaultTimeOutInMinutes;
// if (!double.TryParse(ConfigurationManager.AppSettings["DefaultTimeOut"], out DefaultTimeOutInMinutes))
// {
// DefaultTimeOutInMinutes = 1;
// }
// client.Timeout = TimeSpan.FromMinutes(DefaultTimeOutInMinutes);
//}
return(client);
}
/// <summary>
/// Initializes a new instance of the Table class, and sets all the properties to their initial values.
/// </summary>
/// <param name="columns">Title cells to be added to the header.</param>
public Table(params string[] columns)
{
Header = new HeaderOptions(this);
Footer = new FooterOptions(this);
if (columns.Contains(null))
{
throw new ArgumentException("Cells cannot be null.");
}
Columns = columns.Count();
for (int i = 0; i < Columns; i++)
{
table.Add(new List <string>());
}
AddRow(columns);
}
async public Task <T> PostEntityAsync <T>(string ApiUrl, object parameter, HeaderOptions headerOptions)
{
var client = createInstanceAndHeadder(headerOptions);
Log.Info(string.Format(EXECUTE_LOG_MESSAGE, "POST", ApiUrl, JsonConvert.SerializeObject(parameter)));
HttpResponseMessage response = await client.PostAsJsonAsync(ApiUrl, parameter);
if (response.IsSuccessStatusCode)
{
string resultstr = await response.Content.ReadAsStringAsync();
Log.Info(string.Format("API RESULT:{0}", resultstr));
T result = await response.Content.ReadAsAsync <T>();
Log.Info(string.Format(LEAVE_LOG_MESSAGE, "POST", ApiUrl, string.Empty));
return(result);
}
else if (response.Content.ReadAsStringAsync().Result.Contains("Error code - 13515"))
{
var parameterValue = JsonConvert.SerializeObject(parameter);
string errorMessage = string.Format("<API Error> [RequestMessage]{0} [Response]{1} [Parameter]{2}", response.RequestMessage.ToString(), response.Content.ReadAsStringAsync().Result.ToString(), parameterValue);
Log.Error(errorMessage);
errorMessage = await response.Content.ReadAsStringAsync();
throw new HttpRequestException(errorMessage)
{
Source = response.Content.ReadAsStringAsync().Result
};
}
else
{
var parameterValue = JsonConvert.SerializeObject(parameter);
string errorMessage = string.Format("<API Error> [RequestMessage]{0} [Response]{1} [Parameter]{2}", response.RequestMessage.ToString(), response.ToString(), parameterValue);
Log.Error(errorMessage);
errorMessage = "<API Error>";
throw new HttpRequestException(errorMessage)
{
Source = response?.Content?.ReadAsStringAsync()?.Status.ToString()
};
}
}
private static void ApplyHeader(HeaderOptions obj)
{
var value = "";
switch (obj.FrameOption)
{
case 1:
value = "DENY";
break;
case 2:
value = "SAMEORIGIN";
break;
default:
value = DetermineValue(obj.Origins, obj.RequestUri);
break;
}
obj.Response.Headers[HeaderConstants.XFrameOptions] = value;
}
public void Init(List <Bank> Prg, List <Bank> Chr, HeaderOptions headerOpts)
{
if (_prgRom == MemorySizes.KB_512)
{
//TODO: two of these loops divided between 0xA000 and {0x8000 | 0xC000}
U8 i;
for (i = 0; i < 62; i++)
{
Prg.Add(new Bank(i, MemorySizes.KB_8, 0x8000));
}
Prg.Add(new Bank(++i, MemorySizes.KB_8, 0xC000, true));
Prg.Add(new Bank(++i, MemorySizes.KB_8, 0xE000, true));
headerOpts.PrgRomBanks = 32; //32 * 16KB/bank = 512
}
else
{
throw new NotImplementedException(); //TODO: wait until 512 works to finish the rest
}
if (_chrRom > 0)
{
if (_chrRom == MemorySizes.KB_256)
{
U8 i;
for (i = 0; i < 256; i++)
{
Chr.Add(new Bank(i, MemorySizes.KB_1, 0x0000));
}
headerOpts.ChrRomBanks = 32; //32 * 8KB/bank = 256
}
else
{
throw new NotImplementedException(); //TODO: wait until 512 works to finish the rest
}
}
if (_wRam > 0)
{
WRAM = new RAMRange(Addr(0x6000), Addr(0x7FFF), "WRAM");
}
//headerOpts.
}
void HandlerIsNotCalledWhenNoCorrespondingHeaderKey()
{
var handler = new Mock <IHeaderHandler>(MockBehavior.Strict);
var headerHandlers = new List <KeyValuePair <string, IHeaderHandler> >()
{
new KeyValuePair <string, IHeaderHandler>("aKey", handler.Object)
};
var options = new HeaderOptions(headerHandlers);
var headerValues = new StringValues();
var nextdelegate = new RequestDelegate(CreateDefaultHttpContex);
var logger = Mock.Of <ILogger <HeadersMiddleware> >();
var middleware = new HeadersMiddleware(nextdelegate, logger);
var httpContext = new DefaultHttpContext();
httpContext.Request.Headers.Add("anotherKey", headerValues);
middleware.Invoke(httpContext, Options.Create(options));
handler.Verify();
}
public static bool Has(this HeaderOptions source, HeaderOptions expected)
{
return((source & expected) == expected);
}
async public Task <T> PostContentAsync <T>(string ApiUrl, IEnumerable <KeyValuePair <string, string> > parameters, HeaderOptions headerOptions)
{
var client = createInstanceAndHeadder(headerOptions);
Log.Info(string.Format(EXECUTE_LOG_MESSAGE, "POST", ApiUrl, null));
HttpContent content = new FormUrlEncodedContent(parameters);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
HttpResponseMessage response = await client.PostAsync(ApiUrl, content);
if (response.IsSuccessStatusCode)
{
string resultstr = response.Content.ReadAsStringAsync().Result;
Log.Info(string.Format("API RESULT:{0}", resultstr));
T result = response.Content.ReadAsAsync <T>().Result;
Log.Info(string.Format(LEAVE_LOG_MESSAGE, "POST", ApiUrl, string.Empty));
return(result);
}
else
{
string errorMessage = string.Format("<API Error> [RequestMessage]{0} [Response]{1}", response.RequestMessage.ToString(), response.ToString());
Log.Error(errorMessage);
errorMessage = "<API Error>";
throw new HttpRequestException(errorMessage);
}
}
async public Task <T> PostContentAsync <T>(string ApiUrl, IDictionary <string, Stream> files, HeaderOptions headerOptions)
{
var client = createInstanceAndHeadder(headerOptions);
Log.Info(string.Format(EXECUTE_LOG_MESSAGE, "POST", ApiUrl, null));
var content = new MultipartFormDataContent();
foreach (string fileName in files.Keys)
{
var fileContent = new StreamContent(files[fileName]);
fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = fileName
};
content.Add(fileContent);
}
HttpResponseMessage response = await client.PostAsync(ApiUrl, content);
if (response.IsSuccessStatusCode)
{
string resultstr = response.Content.ReadAsStringAsync().Result;
Log.Info(string.Format("API RESULT:{0}", resultstr));
T result = response.Content.ReadAsAsync <T>().Result;
Log.Info(string.Format(LEAVE_LOG_MESSAGE, "POST", ApiUrl, string.Empty));
return(result);
}
else
{
string errorMessage = string.Format("<API Error> [RequestMessage]{0} [Response]{1}", response.RequestMessage.ToString(), response.ToString());
Log.Error(errorMessage);
errorMessage = "<API Error>";
throw new HttpRequestException(errorMessage);
}
}
public OneSpanSign.API.LayoutOptions ToAPILayoutOptions()
{
if (sdkCeremonyLayoutSettings == null)
{
return(apiLayoutOptions);
}
HeaderOptions headerOptions = new HeaderOptions();
if (sdkCeremonyLayoutSettings.ShowTitle != null || sdkCeremonyLayoutSettings.ProgressBar != null)
{
TitleBarOptions titleBarOptions = new TitleBarOptions();
if (sdkCeremonyLayoutSettings.ShowTitle != null)
{
titleBarOptions.Title = sdkCeremonyLayoutSettings.ShowTitle.Value;
}
if (sdkCeremonyLayoutSettings.ProgressBar != null)
{
titleBarOptions.ProgressBar = sdkCeremonyLayoutSettings.ProgressBar.Value;
}
headerOptions.TitleBar = titleBarOptions;
}
if (sdkCeremonyLayoutSettings.BreadCrumbs != null)
{
headerOptions.Breadcrumbs = sdkCeremonyLayoutSettings.BreadCrumbs.Value;
}
if (sdkCeremonyLayoutSettings.SessionBar != null)
{
headerOptions.SessionBar = sdkCeremonyLayoutSettings.SessionBar.Value;
}
if (sdkCeremonyLayoutSettings.GlobalNavigation != null)
{
headerOptions.GlobalNavigation = sdkCeremonyLayoutSettings.GlobalNavigation.Value;
}
GlobalActionsOptions globalActionsOptions = new GlobalActionsOptions();
if (sdkCeremonyLayoutSettings.ShowGlobalConfirmButton != null)
{
globalActionsOptions.Confirm = sdkCeremonyLayoutSettings.ShowGlobalConfirmButton.Value;
}
if (sdkCeremonyLayoutSettings.ShowGlobalDownloadButton != null)
{
globalActionsOptions.Download = sdkCeremonyLayoutSettings.ShowGlobalDownloadButton.Value;
}
if (sdkCeremonyLayoutSettings.ShowGlobalSaveAsLayoutButton != null)
{
globalActionsOptions.SaveAsLayout = sdkCeremonyLayoutSettings.ShowGlobalSaveAsLayoutButton.Value;
}
headerOptions.GlobalActions = globalActionsOptions;
BrandingBarOptions brandingBarOptions = null;
if (sdkCeremonyLayoutSettings.LogoImageLink != null || sdkCeremonyLayoutSettings.LogoImageSource != null)
{
brandingBarOptions = new BrandingBarOptions();
Image logo = new Image();
logo.Link = sdkCeremonyLayoutSettings.LogoImageLink;
logo.Src = sdkCeremonyLayoutSettings.LogoImageSource;
brandingBarOptions.Logo = logo;
}
LayoutOptions result = new LayoutOptions();
if (sdkCeremonyLayoutSettings.IFrame != null)
{
result.Iframe = sdkCeremonyLayoutSettings.IFrame.Value;
}
if (sdkCeremonyLayoutSettings.Navigator != null)
{
result.Navigator = sdkCeremonyLayoutSettings.Navigator.Value;
}
result.Header = headerOptions;
result.BrandingBar = brandingBarOptions;
return(result);
}
private Silanis.ESL.API.PackageSettings CreateTypicalAPIPackageSettings()
{
Silanis.ESL.API.CeremonySettings apiCeremonySettings = new Silanis.ESL.API.CeremonySettings();
apiCeremonySettings.InPerson = false;
apiCeremonySettings.Ada = true;
apiCeremonySettings.DeclineButton = true;
apiCeremonySettings.OptOutButton = true;
apiCeremonySettings.AddDeclineReason("Decline reason one");
apiCeremonySettings.AddDeclineReason("Decline reason two");
apiCeremonySettings.AddDeclineReason("Decline reason three");
apiCeremonySettings.AddOptOutReason("Opt out reason one");
apiCeremonySettings.AddOptOutReason("Opt out reason two");
apiCeremonySettings.AddOptOutReason("Opt out reason three");
Silanis.ESL.API.Link link = new Silanis.ESL.API.Link();
link.Href = "http://www.google.ca";
link.Text = "click here";
apiCeremonySettings.HandOver = link;
apiCeremonySettings.HideCaptureText = true;
apiCeremonySettings.HideWatermark = true;
apiCeremonySettings.MaxAuthFailsAllowed = 3;
apiCeremonySettings.DisableFirstInPersonAffidavit = true;
apiCeremonySettings.DisableSecondInPersonAffidavit = true;
apiCeremonySettings.HideLanguageDropdown = true;
apiCeremonySettings.HidePackageOwnerInPerson = true;
Style style = new Style();
style.BackgroundColor = "white";
style.Color = "blue";
LayoutStyle layoutStyle = new LayoutStyle();
layoutStyle.Dialog = style;
apiCeremonySettings.Style = layoutStyle;
LayoutOptions layoutOptions = new LayoutOptions();
layoutOptions.Iframe = false;
apiCeremonySettings.Layout = layoutOptions;
HeaderOptions headerOptions = new HeaderOptions();
headerOptions.Breadcrumbs = true;
headerOptions.Feedback = true;
GlobalActionsOptions globalActionsOptions = new GlobalActionsOptions();
globalActionsOptions.Confirm = true;
globalActionsOptions.Download = true;
globalActionsOptions.SaveAsLayout = true;
headerOptions.GlobalActions = globalActionsOptions;
layoutOptions.Header = headerOptions;
Silanis.ESL.API.PackageSettings apiPackageSettings = new Silanis.ESL.API.PackageSettings();
apiPackageSettings.Ceremony = apiCeremonySettings;
return(apiPackageSettings);
}
public BaseResponseGenerator(HeaderOptions showHeaders = HeaderOptions.HideHeaders)
{
ShowHeaders = showHeaders;
}
public HeaderMiddleware(RequestDelegate next, ILogger<HeaderMiddleware> logger, HeaderOptions options )
{
_next = next;
_logger = logger;
_options = options;
}
public DelimitedParserWithValidation(string filePath, HeaderOptions option)
: base(filePath, option, false, true)
{
this.ErrorHandling = ErrorOptions.OnErrorHalt;
}
public SimpleFixedLengthParser(string filePath, HeaderOptions option)
: base(filePath, option, false, true)
{
this.ErrorHandling = ErrorOptions.OnErrorHalt;
}
private ResolveRequestStruct ResolveRequest(RestReq request)
{
var query = new QueryString();
var querystring = "";
if (request.Query != null)
{
foreach (var(key, value) in request.Query)
{
if (value != null)
{
query.Add(key, value);
}
}
querystring = $"?{query}";
}
var url = querystring.Length != 0
? $"{_client.ClientOptions.RestOptions.ApiUrl}v{_client.ClientOptions.RestOptions.Version}/{request.Endpoint}/?{querystring}"
: $"{_client.ClientOptions.RestOptions.ApiUrl}v{_client.ClientOptions.RestOptions.Version}/{request.Endpoint}";
var headers = new HeaderOptions
{
UserAgent = "DiscordBot ($Disharp $0.0.1)",
XRateLimitPrecision = "second"
};
if (request.Auth)
{
if (_token == null)
{
throw new NullReferenceException(
"No bot token has been provided, and is required for the action you are trying to do.");
}
// Provide authorization headers
headers.Authorization = $"{_client.TokenType} {_token}";
}
if (request.Reason != null)
{
headers.XAuditLogReason = Uri.EscapeDataString(request.Reason);
}
var body = JsonConvert.SerializeObject(request.Data);
headers.ContentType = "application/json";
var options = new HttpOptions
{
Method = request.Method,
Headers = new HeaderOptions
{
Authorization = headers.Authorization,
ContentType = headers.ContentType,
UserAgent = headers.UserAgent,
XAuditLogReason = headers.XAuditLogReason,
XRateLimitPrecision = headers.XRateLimitPrecision
},
Body = body,
Files = request.Files
};
// Return the data needed for node-fetch
return(new ResolveRequestStruct
{
Url = url,
Options = options
});
}
public Header(string name, string value, HeaderOptions options = default(HeaderOptions))
{
Name = name;
Value = value;
Options = options;
}
private static Header ReadHeader(ref ReadableBuffer buffer, ref HeaderTable headerTable, int header, int prefixBytes, HeaderOptions options)
{
var index = ReadUInt32(ref buffer, header, prefixBytes);
string name, value;
bool compressed;
if (index == 0)
{
name = ReadString(ref buffer, out compressed);
options |= compressed ? HeaderOptions.NameCompressionOn : HeaderOptions.NameCompressionOff;
}
else
{
name = headerTable.GetHeaderName(index);
}
value = ReadString(ref buffer, out compressed);
options |= compressed ? HeaderOptions.ValueCompressionOn : HeaderOptions.ValueCompressionOff;
return(new Header(name, value, options));
}
