public ServiceProviderEndpoint(EndpointType type, string localPath, string redirectUrl = null, BindingType bindingType = BindingType.NotSet) : this()
{
Type = type;
LocalPath = localPath;
RedirectUrl = redirectUrl;
Binding = bindingType;
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityBindingDetail"/> class.
/// </summary>
/// <param name="entityProperty">The entity property.</param>
/// <param name="valueKey">The value key.</param>
/// <param name="converter">The converter.</param>
/// <param name="bindingType">Type of the binding.</param>
public EntityBindingDetail(PropertyInfo entityProperty, string valueKey, IConverter converter, BindingType bindingType)
{
this.EntityProperty = entityProperty;
this.ValueKey = valueKey;
this.Converter = converter;
this.BindingType = bindingType;
}
public string CalculateRegexFromMethod(BindingType bindingType, MethodInfo methodInfo)
{
// if method name seems to contain regex, we use it as-is
if (nonIdentifierRe.Match(methodInfo.Name).Success)
{
return methodInfo.Name;
}
string stepText = methodInfo.Name;
stepText = RemoveStepPrefix(bindingType, stepText);
var parameters = methodInfo.GetParameters();
int processedPosition = 0;
var reBuilder = new StringBuilder("(?i)");
foreach (var paramPosition in parameters.Select((p, i) => CalculateParamPosition(stepText, p, i)).Where(pp => pp.Position >= 0).OrderBy(pp => pp.Position))
{
if (paramPosition.Position < processedPosition)
continue; //this is an error case -> overlapping parameters
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, paramPosition.Position - processedPosition)));
reBuilder.Append(CalculateParamRegex(parameters[paramPosition.ParamIndex]));
processedPosition = paramPosition.Position + paramPosition.Lenght;
}
reBuilder.Append(CalculateRegex(stepText.Substring(processedPosition, stepText.Length - processedPosition)));
reBuilder.Append(@"\W*");
return reBuilder.ToString();
}
internal void Finalize(MapTemplate map)
{
Map = map;
if (ResetTime == 0)
{
ResetTime = map.DefaultResetTime;
}
//if (Map.Type == MapType.Dungeon)
//{
// IsHeroic = Index == 1;
//}
//else if (MaxPlayerCount != 0)
//{
// // use heuristics to determine whether we have heroic difficulty:
// foreach (var diff in Map.Difficulties)
// {
// if (diff != null && diff.MaxPlayerCount == MaxPlayerCount)
// {
// // Second entry with the same player count -> Probably heroic
// IsHeroic = true;
// break;
// }
// }
//}
IsHeroic = ResetTime == HeroicResetTime;
IsRaid = MaxPlayerCount == MaxDungeonPlayerCount;
BindingType = IsDungeon ? BindingType.Soft : BindingType.Hard;
}
internal BindingSignatureAttribute(BindingType bindingType, string bindingName, params string[] arguments)
: base()
{
this.bindingType = bindingType;
this.bindingName = bindingName;
this.arguments = arguments;
}
public StepBinding(BindingType type, string regexString, MethodInfo methodInfo)
: base(methodInfo)
{
Type = type;
Regex regex = new Regex("^" + regexString + "$", RegexOptions.Compiled | RegexOptions.CultureInvariant);
Regex = regex;
}
public StepArgs(BindingType type, StepDefinitionKeyword stepDefinitionKeyword, string text, string multilineTextArgument, Table tableArgument)
{
Type = type;
StepDefinitionKeyword = stepDefinitionKeyword;
Text = text;
MultilineTextArgument = multilineTextArgument;
TableArgument = tableArgument;
}
public StepInstance(BindingType bindingType, StepDefinitionKeyword stepDefinitionKeyword, string keyword, string stepText, StepScopeNew stepScope)
{
BindingType = bindingType;
StepDefinitionKeyword = stepDefinitionKeyword;
Keyword = keyword;
Text = stepText;
StepScope = stepScope;
}
protected StepDefinitionBaseAttribute(string regex, BindingType[] types)
{
if (types == null) throw new ArgumentNullException("types");
if (types.Length == 0) throw new ArgumentException("List cannot be empty", "types");
Regex = regex;
Types = types;
}
public StepBinding(BindingType type, Regex regex, Delegate bindingAction, Type[] parameterTypes, MethodInfo methodInfo)
{
Type = type;
Regex = regex;
BindingAction = bindingAction;
ParameterTypes = parameterTypes;
MethodInfo = methodInfo;
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityBindingDetail"/> class.
/// </summary>
/// <param name="entityProperty">The entity property.</param>
/// <param name="valueKey">The value key.</param>
/// <param name="bindingType">Type of the binding.</param>
/// <param name="valueWriter">Value writer for the associated value type</param>
/// <param name="valueReader">Value reader for the associated value type</param>
public EntityPropertyConversionDetail(PropertyInfo entityProperty, string valueKey, BindingType bindingType, IBaseValueWriter valueWriter, IBaseValueReader valueReader)
{
this.EntityProperty = entityProperty;
this.ValueKey = valueKey;
this.BindingType = bindingType;
this.ValueWriter = valueWriter;
this.ValueReader = valueReader;
}
public Binding(MemberInfo toMemberInfo, BindingType bindingType, Mapper mapper,
FromDefinition fromDefinition = null)
{
Require.NotNull(toMemberInfo, "toMemberInfo");
BindingType = bindingType;
Mapper = mapper;
ToDefinition = new ToDefinition(toMemberInfo);
FromDefinition = fromDefinition ?? FromUndefinedDefinition.Default;
}
private string RemoveStepPrefix(BindingType bindingType, string stepText)
{
var prefixesToRemove = GetPrefixesToRemove(bindingType);
foreach (var prefixToRemove in prefixesToRemove)
{
if (stepText.StartsWith(prefixToRemove, StringComparison.CurrentCultureIgnoreCase))
{
stepText = stepText.Substring(prefixToRemove.Length).TrimStart('_', ' ');
break; // we only stip one prefix
}
}
return stepText;
}
public BindingEngine Bind(
string destinationProperty,
string sourceProperty,
BindingType bindingType = BindingType.OneWayToDestination)
{
var destinationPropInfo = _destination.GetType().GetProperty(destinationProperty);
var sourcePropInfo = _source.GetType().GetProperty(sourceProperty);
if (destinationPropInfo == null || sourcePropInfo == null) return this;
if (destinationPropInfo.PropertyType != sourcePropInfo.PropertyType) return this;
AssignBindersWith(destinationPropInfo, sourcePropInfo, bindingType);
return this;
}
private static string CreateBinding(string webSiteName, string ip, string hostHeader, string port, BindingType bindingType)
{
var ipAddress = string.IsNullOrWhiteSpace(ip)
? ""
: "-IPAddress \"" + ip + "\"";
var hostHeader2 = string.IsNullOrWhiteSpace(hostHeader)
? ""
: "-HostHeader \"" + hostHeader + "\"";
var commandParams = string.Format("-Name \"{0}\" -Protocol \"{1}\" -Port {2} {3} {4}; ",
webSiteName, bindingType, port, ipAddress, hostHeader2);
var newBinding = "New-WebBinding " + commandParams;
var getBinding = string.Format("$binding = Get-WebBinding " + commandParams + "; if($binding -eq $null) {{ {0} }}", newBinding);
return getBinding;
}
public static ServiceHost GetServiceHost(BindingType bindingType, string externalEndpoint, string authKey, StoreLocation storeLocation, StoreName storeName, string subjectName)
{
// Create an instance of the backup service
BackupService backupService = new BackupService(authKey);
// Add instance to service host
ServiceHost serviceHost = new ServiceHost(backupService);
// Create binding with transport security
Binding binding;
string protocol;
switch (bindingType)
{
case BindingType.Https:
WebHttpBinding httpBinding = new WebHttpBinding(WebHttpSecurityMode.Transport);
httpBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
binding = httpBinding;
protocol = "https";
break;
default: //Tcp
NetTcpBinding tcpBinding = new NetTcpBinding(SecurityMode.Transport);
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
binding = tcpBinding;
protocol = "net.tcp";
break;
}
// Add the service endpoint
ServiceEndpoint ep = serviceHost.AddServiceEndpoint(
typeof(IBackupService),
binding,
String.Format(protocol + "://{0}/BackupService", externalEndpoint));
// Set the x.509 certificate
serviceHost.Credentials.ServiceCertificate.SetCertificate(
storeLocation,
storeName,
X509FindType.FindBySubjectName,
subjectName);
return serviceHost;
}
private IEnumerable<string> GetPrefixesToRemove(BindingType bindingType)
{
yield return bindingType.ToString();
var cultureToSearch = runtimeConfiguration.BindingCulture ?? runtimeConfiguration.FeatureLanguage;
foreach (var keyword in LanguageHelper.GetKeywords(cultureToSearch, bindingType))
{
if (keyword.Contains(' '))
{
yield return keyword.Replace(" ", "_");
yield return keyword.Replace(" ", "");
}
else
{
yield return keyword;
}
}
}
public void Finalize(RegionTemplate region)
{
Region = region;
if (ResetTime == 0)
{
ResetTime = region.DefaultResetTime;
}
foreach (var diff in Region.Difficulties)
{
if (diff.MaxPlayerCount == MaxPlayerCount)
{
// Second entry with the same player count -> Probably heroic
IsHeroic = true;
break;
}
}
BindingType = !IsHeroic && Region.Type == MapType.Dungeon ? BindingType.Soft : BindingType.Hard;
}
protected void AssignBindersWith(PropertyInfo destinationPropInfo, PropertyInfo sourcePropInfo, BindingType bindingType)
{
ValidateBinding(destinationPropInfo, sourcePropInfo, bindingType);
if ((bindingType & BindingType.OneWayToDestination) == BindingType.OneWayToDestination)
{
GetSourceBindersFor(sourcePropInfo.Name)
.Add(new PropertyBinder(destinationPropInfo, sourcePropInfo, _destination, _source));
}
if ((bindingType & BindingType.OneWayToSource) == BindingType.OneWayToSource)
{
GetDestinationBindersFor(destinationPropInfo.Name)
.Add(new PropertyBinder(sourcePropInfo, destinationPropInfo, _source, _destination));
}
if (bindingType == BindingType.OneWayToSource)
RunDestinationBindingFor(destinationPropInfo.Name);
else
RunSourceBindingFor(sourcePropInfo.Name);
}
internal void Finalize(RegionTemplate region)
{
Region = region;
if (ResetTime == 0)
{
ResetTime = region.DefaultResetTime;
}
if (MaxPlayerCount != 0)
{
// use heuristics to determine whether we have a heroic difficulty:
foreach (var diff in Region.Difficulties)
{
if (diff != null && diff.MaxPlayerCount == MaxPlayerCount)
{
// Second entry with the same player count -> Probably heroic
IsHeroic = true;
break;
}
}
}
BindingType = !IsHeroic && Region.Type == MapType.Dungeon ? BindingType.Soft : BindingType.Hard;
}
public Binding(IPropertyChanged source, string sourcePropertyName, IPropertyChanged target, string targetPropertyName, BindingType type = BindingType.TwoWay, IValueConverter converter = null)
{
this.source = source;
this.sourcePropertyName = sourcePropertyName;
this.target = target;
this.targetPropertyName = targetPropertyName;
this.type = type;
this.converter = converter == null ? new NoOpCoverter() : converter;
if (type == BindingType.TwoWay || type == BindingType.OneWay)
{
sourceToTarget = true;
source.PropertyChanged += SourceChanged;
}
if (type == BindingType.TwoWay || type == BindingType.OneWayToSource)
{
targetToSource = true;
target.PropertyChanged += TargetChanged;
}
ValidateBinding();
}
internal ScenarioStepAttribute(BindingType type, string regex)
{
Type = type;
Regex = regex;
}
public static bool Equals(this ScenarioBlock block, BindingType bindingType)
{
return (int)block == (int)bindingType;
}
private static Binding FindBinding(BindingType bType)
{
switch (bType)
{
case BindingType.WebHttp:
WebHttpBinding webHttpBinding = new WebHttpBinding();
webHttpBinding.UseDefaultWebProxy = false;
webHttpBinding.Security.Mode = WebHttpSecurityMode.None;
webHttpBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
webHttpBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
webHttpBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
webHttpBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
webHttpBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
webHttpBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
return(webHttpBinding);
case BindingType.BasicHttp:
BasicHttpBinding basicHttpBinding = new BasicHttpBinding();
basicHttpBinding.UseDefaultWebProxy = false;
basicHttpBinding.Security.Mode = BasicHttpSecurityMode.None;
basicHttpBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
basicHttpBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
basicHttpBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
basicHttpBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
basicHttpBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
basicHttpBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
return(basicHttpBinding);
case BindingType.MsmqIntegration:
MsmqIntegrationBinding msmqIntegrationBinding = new MsmqIntegrationBinding();
msmqIntegrationBinding.ExactlyOnce = false;
msmqIntegrationBinding.UseSourceJournal = true;
msmqIntegrationBinding.Security.Mode = MsmqIntegrationSecurityMode.None;
msmqIntegrationBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
return(msmqIntegrationBinding);
case BindingType.MsmqIntegrationForPubsub:
MsmqIntegrationBinding msmqIntegrationForPubsubBinding = new MsmqIntegrationBinding();
msmqIntegrationForPubsubBinding.ExactlyOnce = false;
msmqIntegrationForPubsubBinding.UseSourceJournal = true;
msmqIntegrationForPubsubBinding.Security.Mode = MsmqIntegrationSecurityMode.Transport;
msmqIntegrationForPubsubBinding.Security.Transport.MsmqAuthenticationMode = MsmqAuthenticationMode.WindowsDomain;
msmqIntegrationForPubsubBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
return(msmqIntegrationForPubsubBinding);
case BindingType.NetMsmq:
NetMsmqBinding netMsmqBinding = new NetMsmqBinding();
//netMsmqBinding.ReaderQuotas.MaxStringContentLength = serviceClient.ReaderQuotasMaxStringContentLength;
netMsmqBinding.ExactlyOnce = false;
netMsmqBinding.UseSourceJournal = true;
netMsmqBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
netMsmqBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
netMsmqBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
netMsmqBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
netMsmqBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
netMsmqBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
//if (credentialType.HasValue)
//{
// netMsmqBinding.Security.Mode = NetMsmqSecurityMode.Message;
// netMsmqBinding.Security.Message.ClientCredentialType = GetMessageCredentialType(credentialType.Value);
// netMsmqBinding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Default;
//}
return(netMsmqBinding);
case BindingType.NetTcp:
NetTcpBinding netTcpBinding = new NetTcpBinding();
//netTcpBinding.ReaderQuotas.MaxStringContentLength = serviceClient.ReaderQuotasMaxStringContentLength;
//netTcpBinding.ReliableSession.Enabled = serviceClient.ReliableSessionEnabled;
//netTcpBinding.ReliableSession.Ordered = serviceClient.ReliableSessionOrdered;
netTcpBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
netTcpBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
netTcpBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
netTcpBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
netTcpBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
netTcpBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
//if (credentialType.HasValue)
//{
// netTcpBinding.Security.Mode = SecurityMode.Message;
// netTcpBinding.Security.Message.ClientCredentialType = GetMessageCredentialType(credentialType.Value);
// netTcpBinding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Default;
//}
return(netTcpBinding);
case BindingType.NetNamedPipe:
NetNamedPipeBinding netNamedPipeBinding = new NetNamedPipeBinding();
netNamedPipeBinding.Security.Mode = NetNamedPipeSecurityMode.None;
netNamedPipeBinding.TransactionFlow = false;
//netNamedPipeBinding.MaxConnections = 100;
netNamedPipeBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
netNamedPipeBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
netNamedPipeBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
netNamedPipeBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
netNamedPipeBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
netNamedPipeBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
return(netNamedPipeBinding);
case BindingType.WSDualHttp:
WSDualHttpBinding wsDualHttpBinding = new WSDualHttpBinding();
//wsDualHttpBinding.ReaderQuotas.MaxStringContentLength = serviceClient.ReaderQuotasMaxStringContentLength;
wsDualHttpBinding.UseDefaultWebProxy = false;
//wsDualHttpBinding.ReliableSession.Ordered = serviceClient.ReliableSessionOrdered;
wsDualHttpBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
wsDualHttpBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
wsDualHttpBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
wsDualHttpBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
wsDualHttpBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
wsDualHttpBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
//if (credentialType.HasValue)
//{
// wsDualHttpBinding.Security.Mode = WSDualHttpSecurityMode.Message;
// wsDualHttpBinding.Security.Message.ClientCredentialType = GetMessageCredentialType(credentialType.Value);
// wsDualHttpBinding.Security.Message.NegotiateServiceCredential = true;
// wsDualHttpBinding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Default;
//}
return(wsDualHttpBinding);
default:
WSHttpBinding wsHttpBinding = new WSHttpBinding();
wsHttpBinding.UseDefaultWebProxy = false;
//wsHttpBinding.ReliableSession.Enabled = serviceClient.ReliableSessionEnabled;
//wsHttpBinding.ReliableSession.Ordered = serviceClient.ReliableSessionOrdered;
wsHttpBinding.MaxReceivedMessageSize = MAX_MSG_SIZE;
wsHttpBinding.ReaderQuotas.MaxStringContentLength = MAX_MSG_SIZE;
wsHttpBinding.ReaderQuotas.MaxArrayLength = MAX_MSG_SIZE;
wsHttpBinding.ReaderQuotas.MaxBytesPerRead = MAX_MSG_SIZE;
wsHttpBinding.ReaderQuotas.MaxDepth = MAX_MSG_SIZE;
wsHttpBinding.ReaderQuotas.MaxNameTableCharCount = MAX_MSG_SIZE;
wsHttpBinding.ReceiveTimeout = new TimeSpan(23, 59, 59);
//if (credentialType.HasValue)
//{
// wsHttpBinding.Security.Mode = SecurityMode.Message;
// wsHttpBinding.Security.Message.ClientCredentialType = GetMessageCredentialType(credentialType.Value);
// wsHttpBinding.Security.Message.NegotiateServiceCredential = true;
// wsHttpBinding.Security.Message.AlgorithmSuite = SecurityAlgorithmSuite.Default;
// wsHttpBinding.Security.Message.EstablishSecurityContext = true;
//}
return(wsHttpBinding);
}
}
private void AddComplexCurve(float time, BindingType bindType, IReadOnlyList <float> curveValues, int offset, string path)
{
switch (bindType)
{
case BindingType.Translation:
{
float x = curveValues[offset + 0];
float y = curveValues[offset + 1];
float z = curveValues[offset + 2];
if (!m_translations.TryGetValue(path, out Vector3Curve transCurve))
{
transCurve = new Vector3Curve(path);
}
Vector3f trans = new Vector3f(x, y, z);
Vector3f defWeight = new Vector3f(1.0f / 3.0f);
KeyframeTpl <Vector3f> transKey = new KeyframeTpl <Vector3f>(time, trans, defWeight);
transCurve.Curve.Curve.Add(transKey);
m_translations[path] = transCurve;
}
break;
case BindingType.Rotation:
{
float x = curveValues[offset + 0];
float y = curveValues[offset + 1];
float z = curveValues[offset + 2];
float w = curveValues[offset + 3];
if (!m_rotations.TryGetValue(path, out QuaternionCurve rotCurve))
{
rotCurve = new QuaternionCurve(path);
}
Quaternionf rot = new Quaternionf(x, y, z, w);
Quaternionf defWeight = new Quaternionf(1.0f / 3.0f);
KeyframeTpl <Quaternionf> rotKey = new KeyframeTpl <Quaternionf>(time, rot, defWeight);
rotCurve.Curve.Curve.Add(rotKey);
m_rotations[path] = rotCurve;
}
break;
case BindingType.Scaling:
{
float x = curveValues[offset + 0];
float y = curveValues[offset + 1];
float z = curveValues[offset + 2];
if (!m_scales.TryGetValue(path, out Vector3Curve scaleCurve))
{
scaleCurve = new Vector3Curve(path);
}
Vector3f scale = new Vector3f(x, y, z);
Vector3f defWeight = new Vector3f(1.0f / 3.0f);
KeyframeTpl <Vector3f> scaleKey = new KeyframeTpl <Vector3f>(time, scale, defWeight);
scaleCurve.Curve.Curve.Add(scaleKey);
m_scales[path] = scaleCurve;
}
break;
case BindingType.EulerRotation:
{
float x = curveValues[offset + 0];
float y = curveValues[offset + 1];
float z = curveValues[offset + 2];
if (!m_eulers.TryGetValue(path, out Vector3Curve eulerCurve))
{
eulerCurve = new Vector3Curve(path);
}
Vector3f euler = new Vector3f(x, y, z);
Vector3f defWeight = new Vector3f(1.0f / 3.0f);
KeyframeTpl <Vector3f> eulerKey = new KeyframeTpl <Vector3f>(time, euler, defWeight);
eulerCurve.Curve.Curve.Add(eulerKey);
m_eulers[path] = eulerCurve;
}
break;
case BindingType.Floats:
{
float value = curveValues[offset];
if (!m_floats.TryGetValue(path, out FloatCurve floatCurve))
{
floatCurve = new FloatCurve(path);
}
Float @float = new Float(value);
Float defWeight = new Float(1.0f / 3.0f);
KeyframeTpl <Float> floatKey = new KeyframeTpl <Float>(time, @float, defWeight);
floatCurve.Curve.Curve.Add(floatKey);
m_floats[path] = floatCurve;
}
break;
default:
throw new NotImplementedException(bindType.ToString());
}
}
public void Type(BindingType bindingType) => BindingType = bindingType;
private string writeFunctions()
{
StringBuilder sb = new StringBuilder();
foreach (Function ft in model.Functions)
{
List <string> parameters = new List <string>();
sb.AppendLine(" /**");
sb.AppendLine(string.Format(" * {0}", ft.Description));
bool isBound = ft.BoundTypes.Count > 0;
if (isBound)
{
List <string> boundToTypes = new List <string>();
BindingType bindingtype = ft.BoundTypes.FirstOrDefault().BoundTo;
foreach (Binding b in ft.BoundTypes)
{
boundToTypes.Add(b.Type);
}
parameters.Add("uri: string");
if (bindingtype == BindingType.Collection)
{
sb.AppendLine(string.Format(" * @param uri A url for a collection of {0} to apply the function to.", string.Join(",", boundToTypes.ToArray())));
}
else
{
sb.AppendLine(string.Format(" * @param uri A url for a {0} to apply the function to.", string.Join(",", boundToTypes.ToArray())));
}
}
foreach (Parameter p in ft.Parameters)
{
sb.AppendLine(string.Format(" * @param {0} {1}", lowerCaseFirstLetter(p.Name), p.Description));
string typeName = trimNameSpace(getJSType(p.Type), RootNameSpace, SubNamespace);
parameters.Add(string.Format("{0}: {1}", lowerCaseFirstLetter(p.Name), typeName));
}
if (ft.IsComposable)
{
parameters.Add("query?: string");
parameters.Add("includeFormattedValues?: boolean");
}
if (!excludeCallerId.Contains(ft.Name))
{
parameters.Add("callerId?: string");
sb.AppendLine(string.Format(" * @param {0} {1}", "callerId", "A string representation of the GUID value for the user to impersonate"));
}
sb.AppendLine(" */");
sb.Append(string.Format(" function {0}(", ft.Name));
if (parameters.Count > 0)
{
sb.AppendLine();
sb.Append(" ");
sb.Append(string.Format("{0}", string.Join("," + Environment.NewLine + " ", parameters.ToArray())));
sb.AppendLine();
}
string returnTypeName = trimNameSpace(getJSType(ft.ReturnType), RootNameSpace, SubNamespace);
sb.Append(string.Format("): Promise<{0}>;", returnTypeName));
sb.AppendLine();
}
return(sb.ToString());
}
public Shape(string name, BindingType bindingType)
{
this.name = name;
this.bindingType = bindingType;
}
private void GetCompletionsForBindingType(BindingType bindingType, out IEnumerable<Completion> completions, out IEnumerable<Completion> completionBuilders)
{
completionBuilders = null;
var suggestionProvider = languageService.ProjectScope.StepSuggestionProvider;
if (suggestionProvider == null)
{
completions = Enumerable.Empty<Completion>();
return;
}
if (!suggestionProvider.Populated)
{
string percentText = string.Format("({0}% completed)", suggestionProvider.GetPopulationPercent());
completionBuilders = new[] {new Completion(
(!suggestionProvider.BindingsPopulated ?
"step suggestion list is being populated... " :
"step suggestion list from existing feature files is being populated... ") + percentText)};
}
try
{
completions = suggestionProvider.GetNativeSuggestionItems(bindingType);
}
catch(Exception)
{
//fallback case
completions = Enumerable.Empty<Completion>();
}
}
public DataBindingTargetResolver(FieldCollection fields, PathCollection paths)
: this(fields)
{
this.items = paths;
this.BindingType = BindingType.Paths;
}
public DataBindingTargetResolver(FieldCollection fields, GroupCollection groups)
: this(fields)
{
this.items = groups;
this.BindingType = BindingType.Groups;
}
public DataBindingTargetResolver(FieldCollection fields, ShapeCollection shapes)
: this(fields)
{
this.items = shapes;
this.BindingType = BindingType.Shapes;
}
public void SetBindingType(BindingType type, IDataSetProvider provider)
{
OnBindingTypeChanged(type, provider);
}
public static void AddServiceInfo(string adress, BindingType bType, string contract)
{
s_List.Add(new ServiceInfo {
Address = adress, Binding = bType, Contract = contract
});
}
public StandardServiceFactory(BindingType bindingType, string bizExceptionTypeName, string exceptionHandlerTypeName)
{
m_BindingType = bindingType;
m_BizExceptionTypeName = bizExceptionTypeName;
m_ExceptionHandlerTypeName = exceptionHandlerTypeName;
}
private static BindingMetadata ParseBindingMetadata(JObject binding, INameResolver nameResolver)
{
BindingMetadata bindingMetadata = null;
string bindingTypeValue = (string)binding["type"];
string bindingDirectionValue = (string)binding["direction"];
string connection = (string)binding["connection"];
BindingType bindingType = default(BindingType);
BindingDirection bindingDirection = default(BindingDirection);
if (!string.IsNullOrEmpty(bindingDirectionValue) &&
!Enum.TryParse <BindingDirection>(bindingDirectionValue, true, out bindingDirection))
{
throw new FormatException(string.Format(CultureInfo.InvariantCulture, "'{0}' is not a valid binding direction.", bindingDirectionValue));
}
if (!string.IsNullOrEmpty(bindingTypeValue) &&
!Enum.TryParse <BindingType>(bindingTypeValue, true, out bindingType))
{
throw new FormatException(string.Format("'{0}' is not a valid binding type.", bindingTypeValue));
}
if (!string.IsNullOrEmpty(connection) &&
string.IsNullOrEmpty(Utility.GetAppSettingOrEnvironmentValue(connection)))
{
throw new FormatException("Invalid Connection value specified.");
}
switch (bindingType)
{
case BindingType.EventHubTrigger:
case BindingType.EventHub:
bindingMetadata = binding.ToObject <EventHubBindingMetadata>();
break;
case BindingType.QueueTrigger:
case BindingType.Queue:
bindingMetadata = binding.ToObject <QueueBindingMetadata>();
break;
case BindingType.BlobTrigger:
case BindingType.Blob:
bindingMetadata = binding.ToObject <BlobBindingMetadata>();
break;
case BindingType.ServiceBusTrigger:
case BindingType.ServiceBus:
bindingMetadata = binding.ToObject <ServiceBusBindingMetadata>();
break;
case BindingType.HttpTrigger:
bindingMetadata = binding.ToObject <HttpTriggerBindingMetadata>();
break;
case BindingType.Http:
bindingMetadata = binding.ToObject <HttpBindingMetadata>();
break;
case BindingType.Table:
bindingMetadata = binding.ToObject <TableBindingMetadata>();
break;
case BindingType.ManualTrigger:
bindingMetadata = binding.ToObject <BindingMetadata>();
break;
case BindingType.TimerTrigger:
bindingMetadata = binding.ToObject <TimerBindingMetadata>();
break;
case BindingType.MobileTable:
bindingMetadata = binding.ToObject <MobileTableBindingMetadata>();
break;
case BindingType.DocumentDB:
bindingMetadata = binding.ToObject <DocumentDBBindingMetadata>();
break;
case BindingType.NotificationHub:
bindingMetadata = binding.ToObject <NotificationHubBindingMetadata>();
break;
case BindingType.ApiHubFile:
case BindingType.ApiHubFileTrigger:
bindingMetadata = binding.ToObject <ApiHubBindingMetadata>();
break;
case BindingType.ApiHubTable:
bindingMetadata = binding.ToObject <ApiHubTableBindingMetadata>();
break;
}
bindingMetadata.Type = bindingType;
bindingMetadata.Direction = bindingDirection;
bindingMetadata.Connection = connection;
nameResolver.ResolveAllProperties(bindingMetadata);
return(bindingMetadata);
}
public StepDefinitionBinding(RuntimeConfiguration runtimeConfiguration, IErrorProvider errorProvider, BindingType type, string regexString, MethodInfo methodInfo, BindingScope bindingScope)
: base(runtimeConfiguration, errorProvider, methodInfo)
{
Type = type;
Regex regex = new Regex("^" + regexString + "$", RegexOptions);
Regex = regex;
this.BindingScope = bindingScope;
}
/// <summary>
/// Warning: Requires Character to be logged in and to be in Character's context.
/// Often you might want to use ForeachBinding() instead.
/// </summary>
public void ForeachBinding(BindingType type, Action<InstanceBinding> callback)
{
var bindings = m_bindings[(int)type];
if (bindings != null)
{
lock (bindings)
{
foreach (var binding in bindings)
{
callback(binding);
}
}
}
}
public static void HandleKeyBinding(BindingType bindingType, string bindingsPath, string bindsName)
{
Logger.Instance.LogMessage(TracingLevel.INFO, "handle key binding " + bindsName);
if (KeyBindingWatcher[(int)bindingType] != null)
{
KeyBindingWatcher[(int)bindingType].StopWatching();
KeyBindingWatcher[(int)bindingType].Dispose();
KeyBindingWatcher[(int)bindingType] = null;
}
var fileName = Path.Combine(bindingsPath, bindsName + ".4.0.binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "file not found " + fileName);
fileName = fileName.Replace(".4.0.binds", ".3.0.binds");
if (!File.Exists(fileName))
{
fileName = fileName.Replace(".3.0.binds", ".binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "file not found " + fileName);
}
}
}
// steam
if (!File.Exists(fileName))
{
bindingsPath = SteamPath.FindSteamEliteDirectory();
if (!string.IsNullOrEmpty(bindingsPath))
{
fileName = Path.Combine(bindingsPath, bindsName + ".4.0.binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "steam file not found " + fileName);
fileName = fileName.Replace(".4.0.binds", ".3.0.binds");
if (!File.Exists(fileName))
{
fileName = fileName.Replace(".3.0.binds", ".binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "steam file not found " + fileName);
}
}
}
}
}
// epic
if (!File.Exists(fileName))
{
bindingsPath = EpicPath.FindEpicEliteDirectory();
if (!string.IsNullOrEmpty(bindingsPath))
{
fileName = Path.Combine(bindingsPath, bindsName + ".4.0.binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "epic file not found " + fileName);
fileName = fileName.Replace(".4.0.binds", ".3.0.binds");
if (!File.Exists(fileName))
{
fileName = fileName.Replace(".3.0.binds", ".binds");
if (!File.Exists(fileName))
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "epic file not found " + fileName);
}
}
}
}
}
if (File.Exists(fileName))
{
var serializer = new XmlSerializer(typeof(UserBindings));
//Logger.Instance.LogMessage(TracingLevel.INFO, "using " + fileName);
var reader = new StreamReader(fileName);
Binding[bindingType] = (UserBindings)serializer.Deserialize(reader);
reader.Close();
var keyBindingPath = Path.GetDirectoryName(fileName);
Logger.Instance.LogMessage(TracingLevel.INFO, "monitoring key binding path #2 " + keyBindingPath);
var keyBindingFileName = Path.GetFileName(fileName);
Logger.Instance.LogMessage(TracingLevel.INFO, "monitoring key binding file name #2 " + keyBindingFileName);
KeyBindingWatcher[(int)bindingType] = new KeyBindingWatcher(keyBindingPath, keyBindingFileName);
KeyBindingWatcher[(int)bindingType].KeyBindingUpdated += HandleKeyBindingEvents;
KeyBindingWatcher[(int)bindingType].StartWatching();
}
else
{
Logger.Instance.LogMessage(TracingLevel.ERROR, "file not found " + fileName);
}
}
/// <summary>
/// Munges a binding name.
/// </summary>
/// <param name="name">The binding name to munge.</param>
/// <param name="paramCount">
/// The number of parameters in the binding.
/// </param>
/// <returns>The munged name</returns>
public static string MungeName(BindingType type, string name, int paramCount)
{
return(string.Format("{0}:{1}@{2}", type, name, paramCount));
}
private string writeActions()
{
StringBuilder sb = new StringBuilder();
foreach (CrmWebAPIModel.Action at in model.Actions)
{
List <string> parameters = new List <string>();
sb.AppendLine(" /**");
sb.AppendLine(string.Format(" * {0}", at.Description));
bool isBound = at.BoundTypes.Count > 0;
if (isBound)
{
List <string> boundToTypes = new List <string>();
BindingType bindingtype = at.BoundTypes.FirstOrDefault().BoundTo;
foreach (Binding b in at.BoundTypes)
{
boundToTypes.Add(b.Type);
}
parameters.Add("uri: string");
if (bindingtype == BindingType.Collection)
{
sb.AppendLine(string.Format(" * @param uri A url for a collection of {0} to apply the action to.", string.Join(",", boundToTypes.ToArray())));
}
else
{
sb.AppendLine(string.Format(" * @param uri A url for a {0} to apply the action to.", string.Join(",", boundToTypes.ToArray())));
}
}
foreach (Parameter p in at.Parameters)
{
sb.AppendLine(string.Format(" * @param {0} {1} {2}", lowerCaseFirstLetter(p.Name), p.Description, (p.Nullable)? "(Required parameter can be null)" : "(Required)"));
string typeName = trimNameSpace(getJSType(p.Type), RootNameSpace, SubNamespace);
parameters.Add(string.Format("{0}: {1}", lowerCaseFirstLetter(p.Name), typeName));
}
parameters.Add("callerId?: string");
sb.AppendLine(string.Format(" * @param {0} {1}", "[callerId]", "A string representation of the GUID value for the user to impersonate"));
sb.AppendLine(" */");
sb.Append(string.Format(" function {0}(", at.Name));
if (parameters.Count > 0)
{
sb.Append(Environment.NewLine + " ");
sb.Append(string.Format("{0}", string.Join("," + Environment.NewLine + " ", parameters.ToArray())));
sb.Append(Environment.NewLine + " ");
}
if (at.ReturnType != null)
{
string returnTypeName = trimNameSpace(getJSType(at.ReturnType), RootNameSpace, SubNamespace);
sb.Append(string.Format("): Promise<{0}>;", returnTypeName));
}
else
{
sb.Append("): Promise<void>;");
}
sb.AppendLine();
}
return(sb.ToString());
}
public Shape(string name, BindingType bindingType)
{
this.name = name;
this.bindingType = bindingType;
}
public BindingKey(object target, BindingType type)
{
this.Target = target;
this.Type = type;
}
/// <summary> /// Converts the <paramref name="sourceValue" /> parameter to the <paramref name="destinationType" /> parameter using <paramref /// name="formatProvider" /> and <paramref name="ignoreCase" /> /// </summary> /// <param name="sourceValue">the <see cref="System.Object"/> to convert from</param> /// <param name="destinationType">the <see cref="System.Type" /> to convert to</param> /// <param name="formatProvider">not used by this TypeConverter.</param> /// <param name="ignoreCase">when set to <c>true</c>, will ignore the case when converting.</param> /// <returns> /// an instance of <see cref="BindingType" />, or <c>null</c> if there is no suitable conversion. /// </returns> public override object ConvertFrom(object sourceValue, global::System.Type destinationType, global::System.IFormatProvider formatProvider, bool ignoreCase) => BindingType.CreateFrom(sourceValue);
// Which SubIndexes have subscriptions?
public IEnumerable <int> GetKeys(BindingType bindingType, int index)
{
return(_bindings[bindingType][index].GetKeys());
}
public SearchOptions(string nameRegex = null, string assemblyRegex = null, ScopeType scope = ScopeType.All, BindingType binding = BindingType.All, object instance = null)
{
NameRegex = ((nameRegex == null) ? null : new Regex(nameRegex));
AssemblyRegex = ((assemblyRegex == null) ? null : new Regex(assemblyRegex));
Scope = scope;
Binding = binding;
weakInstance = ((instance != null) ? new WeakReference(instance) : null);
}
internal StepDefinitionBaseAttribute(string regex, BindingType type)
: this(regex, new[] { type })
{
}
public int Count(BindingType bindingType)
{
return(ContainsKey(bindingType) ? _bindings[bindingType].Count() : 0);
}
private void ValidateBinding(PropertyInfo destinationPropInfo, PropertyInfo sourcePropInfo, BindingType bindingType)
{
if ((bindingType & BindingType.OneWayToDestination) == BindingType.OneWayToDestination)
{
if (!sourcePropInfo.CanRead)
throw new PropertyIsNotReadableException(sourcePropInfo);
if (!destinationPropInfo.CanWrite)
throw new PropertyIsNotWritableException(destinationPropInfo);
}
if ((bindingType & BindingType.OneWayToSource) == BindingType.OneWayToSource)
{
if (!destinationPropInfo.CanRead)
throw new PropertyIsNotReadableException(destinationPropInfo);
if (!sourcePropInfo.CanWrite)
throw new PropertyIsNotWritableException(sourcePropInfo);
}
}
public int Count(BindingType bindingType, int index)
{
return(ContainsKey(bindingType, index) ? _bindings[bindingType][index].Count() : 0);
}
// Are there any Axis / Button / POV subscriptions?
public bool ContainsKey(BindingType bindingType)
{
return(_bindings.ContainsKey(bindingType));
}
// Which Axes / Buttons have subscriptions?
public bool ContainsKey(BindingType bindingType, int index)
{
return(_bindings.ContainsKey(bindingType) && _bindings[bindingType].ContainsKey(index));
}
internal ScenarioStepAttribute(BindingType type, string regex)
{
Type = type;
Regex = regex;
}
public bool ContainsKey(BindingType bindingType, int index, int subIndex)
{
return(ContainsKey(bindingType, index) && _bindings[bindingType][index].ContainsKey(subIndex));
}
private Task CompleteSsoAsync(HttpContext context, SamlResponse response, Uri destination, BindingType binding)
{
var base64 = SerializeSamlResponse(response, binding);
if (binding == BindingType.Post)
{
return(PostAsync(context, base64, destination, response.RelayState));
}
if (binding == BindingType.Redirect)
{
return(RedirectAsync(context, base64, destination, response.RelayState));
}
throw new ArgumentException($"Unsupported binding type: '{binding}'");
}
public BindToInfo(string name, object handlers, BindingType type)
{
Name = name;
Handlers = HtmlHelper.AnonymousObjectToHtmlAttributes(handlers);
Type = type;
}
/// <summary>
/// Returns the Cooldown object for the Instance with the given MapId.
/// </summary>
/// <param name="map">The MapId of the Instance in question.</param>
/// <returns></returns>
public InstanceBinding GetBinding(MapId map, BindingType type)
{
var bindings = m_bindings[(int)type];
if (bindings == null)
{
return null;
}
lock (bindings)
{
foreach (var binding in bindings)
{
if (binding.MapId == map)
{
return binding;
}
}
}
return null;
}
public MvxWindowsBindingBuilder(
BindingType bindingType = BindingType.MvvmCross)
{
_bindingType = bindingType;
}
private List<InstanceBinding> GetOrCreateBindingList(BindingType type)
{
lock (m_bindings)
{
var bindings = m_bindings[(int)type];
if (bindings == null)
{
m_bindings[(int)type] = bindings = InstanceBindingListPool.Obtain();
}
return bindings;
}
}
// Which Indexes have subscriptions?
public IEnumerable <int> GetKeys(BindingType bindingType)
{
return(_bindings[bindingType].GetKeys());
}
