public static bool IsDefined(TransactionFlowOption option)
{
return(option == TransactionFlowOption.NotAllowed ||
option == TransactionFlowOption.Allowed ||
option == TransactionFlowOption.Mandatory);
//option == TransactionFlowOption.Ignore);
}
internal static void ValidateOption(TransactionFlowOption opt)
{
if (!TransactionFlowOptionHelper.IsDefined(opt))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(System.ServiceModel.SR.GetString("TransactionFlowBadOption")));
}
}
public static bool IsDefined(TransactionFlowOption option)
{
return (option == TransactionFlowOption.NotAllowed ||
option == TransactionFlowOption.Allowed ||
option == TransactionFlowOption.Mandatory);
//option == TransactionFlowOption.Ignore);
}
private XmlElement GetAssertion(XmlDocument doc, TransactionFlowOption option, string prefix, string name, string ns, string policyNs)
{
if (doc == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("doc");
}
XmlElement element = null;
switch (option)
{
case TransactionFlowOption.NotAllowed:
return(element);
case TransactionFlowOption.Allowed:
{
element = doc.CreateElement(prefix, name, ns);
System.Xml.XmlAttribute node = doc.CreateAttribute("wsp", "Optional", policyNs);
node.Value = "true";
element.Attributes.Append(node);
if ((this.transactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions) || (this.transactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004))
{
System.Xml.XmlAttribute attribute2 = doc.CreateAttribute("wsp1", "Optional", "http://schemas.xmlsoap.org/ws/2002/12/policy");
attribute2.Value = "true";
element.Attributes.Append(attribute2);
}
return(element);
}
case TransactionFlowOption.Mandatory:
return(doc.CreateElement(prefix, name, ns));
}
return(element);
}
internal static void ValidateOption(TransactionFlowOption opt)
{
if (!TransactionFlowOptionHelper.IsDefined(opt))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(string.Format(SRServiceModel.TransactionFlowBadOption)));
}
}
internal static bool AllowedOrRequired(TransactionFlowOption option)
{
if (option != TransactionFlowOption.Allowed)
{
return(option == TransactionFlowOption.Mandatory);
}
return(true);
}
public static bool IsDefined(TransactionFlowOption option)
{
if ((option != TransactionFlowOption.NotAllowed) && (option != TransactionFlowOption.Allowed))
{
return (option == TransactionFlowOption.Mandatory);
}
return true;
}
internal static bool AllowedOrRequired(TransactionFlowOption option)
{
if (option != TransactionFlowOption.Allowed)
{
return (option == TransactionFlowOption.Mandatory);
}
return true;
}
public static bool IsDefined(TransactionFlowOption option)
{
if ((option != TransactionFlowOption.NotAllowed) && (option != TransactionFlowOption.Allowed))
{
return(option == TransactionFlowOption.Mandatory);
}
return(true);
}
public virtual void ReadTransactionDataFromMessage(Message message, MessageDirection direction)
{
this.ReadIssuedTokens(message, direction);
TransactionFlowOption transaction = this.factory.GetTransaction(direction, message.Headers.Action);
if (TransactionFlowOptionHelper.AllowedOrRequired(transaction))
{
this.ReadTransactionFromMessage(message, transaction);
}
}
internal TransactionFlowBindingElement(bool transactions, System.ServiceModel.TransactionProtocol transactionProtocol)
{
this.transactions = transactions;
this.issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed;
if (!System.ServiceModel.TransactionProtocol.IsDefined(transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.ServiceModel.SR.GetString("ConfigInvalidTransactionFlowProtocolValue", new object[] { transactionProtocol.ToString() }));
}
this.transactionProtocol = transactionProtocol;
}
private TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned) : base(elementToBeCloned)
{
this.transactions = elementToBeCloned.transactions;
this.issuedTokens = elementToBeCloned.issuedTokens;
if (!System.ServiceModel.TransactionProtocol.IsDefined(elementToBeCloned.transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(System.ServiceModel.SR.GetString("ConfigInvalidTransactionFlowProtocolValue", new object[] { elementToBeCloned.transactionProtocol.ToString() }));
}
this.transactionProtocol = elementToBeCloned.transactionProtocol;
this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction;
}
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol)
{
_transactions = transactions;
_issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed;
if (!TransactionProtocol.IsDefined(transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString()));
}
_transactionProtocol = transactionProtocol;
}
private static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option, ref TransactionFlowOption agreedOption, ref bool anOperationCares)
{
if (!anOperationCares)
{
agreedOption = option;
anOperationCares = true;
}
else if (option != agreedOption)
{
everyoneAgrees = false;
}
}
internal TransactionFlowBindingElement(bool transactions, TransactionProtocol transactionProtocol)
{
this.transactions = transactions;
this.issuedTokens = transactions ? TransactionFlowOption.Allowed : TransactionFlowOption.NotAllowed;
if (!TransactionProtocol.IsDefined(transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, transactionProtocol.ToString()));
}
this.transactionProtocol = transactionProtocol;
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
TransactionFlowBindingElement bindingElement = context.BindingElements.Find <TransactionFlowBindingElement>();
if (bindingElement == null || !bindingElement.Transactions)
{
return;
}
XmlDocument doc = new XmlDocument();
XmlElement assertion = null;
foreach (OperationDescription operation in context.Contract.Operations)
{
TransactionFlowAttribute contextParam = operation.Behaviors.Find <TransactionFlowAttribute>();
TransactionFlowOption txFlowOption = contextParam == null ? TransactionFlowOption.NotAllowed : contextParam.Transactions;
// Transactions
if (bindingElement.TransactionProtocol == TransactionProtocol.OleTransactions)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.OleTxTransactionsPrefix, TransactionPolicyStrings.OleTxTransactionsLocal,
TransactionPolicyStrings.OleTxTransactionsNamespace, exporter.PolicyVersion.Namespace);
}
else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal,
TransactionPolicyStrings.WsatTransactionsNamespace10, exporter.PolicyVersion.Namespace);
}
else if (bindingElement.TransactionProtocol == TransactionProtocol.WSAtomicTransaction11)
{
assertion = GetAssertion(doc, txFlowOption,
TransactionPolicyStrings.WsatTransactionsPrefix, TransactionPolicyStrings.WsatTransactionsLocal,
TransactionPolicyStrings.WsatTransactionsNamespace11, exporter.PolicyVersion.Namespace);
}
if (assertion != null)
{
context.GetOperationBindingAssertions(operation).Add(assertion);
}
}
}
public void WriteTransactionDataToMessage(Message message, MessageDirection direction)
{
TransactionFlowOption transaction = this.factory.GetTransaction(direction, message.Headers.Action);
if (TransactionFlowOptionHelper.AllowedOrRequired(transaction))
{
this.WriteTransactionToMessage(message, transaction);
}
if (TransactionFlowOptionHelper.AllowedOrRequired(this.factory.FlowIssuedTokens))
{
this.WriteIssuedTokens(message, direction);
}
}
internal static void OverrideFlow(BindingParameterCollection parameters, string action, MessageDirection direction, TransactionFlowOption option)
{
Dictionary<DirectionalAction, TransactionFlowOption> dictionary = EnsureDictionary(parameters);
DirectionalAction key = new DirectionalAction(direction, action);
if (dictionary.ContainsKey(key))
{
dictionary[key] = option;
}
else
{
dictionary.Add(key, option);
}
}
TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
this.transactions = elementToBeCloned.transactions;
this.issuedTokens = elementToBeCloned.issuedTokens;
if (!TransactionProtocol.IsDefined(elementToBeCloned.transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned.transactionProtocol.ToString()));
}
this.transactionProtocol = elementToBeCloned.transactionProtocol;
this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction;
}
private TransactionFlowBindingElement(TransactionFlowBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
_transactions = elementToBeCloned._transactions;
_issuedTokens = elementToBeCloned._issuedTokens;
if (!TransactionProtocol.IsDefined(elementToBeCloned._transactionProtocol))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(string.Format(SRServiceModel.ConfigInvalidTransactionFlowProtocolValue, elementToBeCloned._transactionProtocol.ToString()));
}
_transactionProtocol = elementToBeCloned._transactionProtocol;
this.AllowWildcardAction = elementToBeCloned.AllowWildcardAction;
}
internal static void OverrideFlow(BindingParameterCollection parameters, string action, MessageDirection direction, TransactionFlowOption option)
{
Dictionary <DirectionalAction, TransactionFlowOption> dictionary = EnsureDictionary(parameters);
DirectionalAction key = new DirectionalAction(direction, action);
if (dictionary.ContainsKey(key))
{
dictionary[key] = option;
}
else
{
dictionary.Add(key, option);
}
}
void SetTransactionFlow(OperationDescription operation)
{
TransactionFlowOption option = TransactionFlowOption.NotAllowed;
foreach (IOperationBehavior behavior in operation.Behaviors)
{
if (behavior is TransactionFlowAttribute)
{
TransactionFlowAttribute attribute = behavior as TransactionFlowAttribute;
option = attribute.Transactions;
break;
}
}
m_AllowedRadioButton.Checked = option == TransactionFlowOption.Allowed;
m_NotAllowedRadioButton.Checked = option == TransactionFlowOption.NotAllowed;
m_MandatoryRadioButton.Checked = option == TransactionFlowOption.Mandatory;
}
public void ReadIssuedTokens(Message message, MessageDirection direction)
{
TransactionFlowOption flowIssuedTokens = this.factory.FlowIssuedTokens;
ICollection <RequestSecurityTokenResponse> issuedTokens = this.GetIssuedTokens(message);
if ((issuedTokens != null) && (issuedTokens.Count != 0))
{
if (flowIssuedTokens == TransactionFlowOption.NotAllowed)
{
this.FaultOnMessage(message, System.ServiceModel.SR.GetString("IssuedTokenFlowNotAllowed"), "IssuedTokenFlowNotAllowed");
}
foreach (RequestSecurityTokenResponse response in issuedTokens)
{
TransactionFlowProperty.Ensure(message).IssuedTokens.Add(response);
}
}
}
static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option,
ref TransactionFlowOption agreedOption, ref bool anOperationCares)
{
if (!anOperationCares)
{
// this is the first operation to express a preference
agreedOption = option;
anOperationCares = true;
// everyoneAgrees is still true
}
else
{
if (option != agreedOption)
{
everyoneAgrees = false;
}
}
}
public void ReadIssuedTokens(Message message, MessageDirection direction)
{
TransactionFlowOption option = this.factory.FlowIssuedTokens;
ICollection <RequestSecurityTokenResponse> issuances = this.GetIssuedTokens(message);
if (issuances != null && issuances.Count != 0)
{
if (option == TransactionFlowOption.NotAllowed)
{
FaultOnMessage(message, SR.GetString(SR.IssuedTokenFlowNotAllowed), FaultCodeConstants.Codes.IssuedTokenFlowNotAllowed);
}
foreach (RequestSecurityTokenResponse rstr in issuances)
{
TransactionFlowProperty.Ensure(message).IssuedTokens.Add(rstr);
}
}
}
void WriteTransactionToMessage(Message message, TransactionFlowOption txFlowOption)
{
Transaction transaction = TransactionFlowProperty.TryGetTransaction(message);
if (transaction != null)
{
try
{
this.formatter.WriteTransaction(transaction, message);
}
catch (TransactionException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(e.Message, e));
}
}
else if (txFlowOption == TransactionFlowOption.Mandatory)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(SR.GetString(SR.SFxTransactionFlowRequired)));
}
}
XmlElement GetAssertion(XmlDocument doc, TransactionFlowOption option, string prefix, string name, string ns, string policyNs)
{
if (doc == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("doc");
}
XmlElement result = null;
switch (option)
{
case TransactionFlowOption.NotAllowed:
// Don't generate an assertion
break;
case TransactionFlowOption.Allowed:
result = doc.CreateElement(prefix, name, ns);
// Always insert the real wsp:Optional attribute
XmlAttribute attr = doc.CreateAttribute(TransactionPolicyStrings.OptionalPrefix11,
TransactionPolicyStrings.OptionalLocal, policyNs);
attr.Value = TransactionPolicyStrings.TrueValue;
result.Attributes.Append(attr);
// For legacy protocols, also insert the legacy attribute for backward compat
if (this.transactionProtocol == TransactionProtocol.OleTransactions ||
this.transactionProtocol == TransactionProtocol.WSAtomicTransactionOctober2004)
{
XmlAttribute attrLegacy = doc.CreateAttribute(TransactionPolicyStrings.OptionalPrefix10,
TransactionPolicyStrings.OptionalLocal, TransactionPolicyStrings.OptionalNamespaceLegacy);
attrLegacy.Value = TransactionPolicyStrings.TrueValue;
result.Attributes.Append(attrLegacy);
}
break;
case TransactionFlowOption.Mandatory:
result = doc.CreateElement(prefix, name, ns);
break;
}
return(result);
}
private void WriteTransactionToMessage(Message message, TransactionFlowOption txFlowOption)
{
Transaction transaction = TransactionFlowProperty.TryGetTransaction(message);
if (transaction != null)
{
try
{
this.formatter.WriteTransaction(transaction, message);
return;
}
catch (TransactionException exception)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(exception.Message, exception));
}
}
if (txFlowOption == TransactionFlowOption.Mandatory)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ProtocolException(System.ServiceModel.SR.GetString("SFxTransactionFlowRequired")));
}
}
private void ReadTransactionFromMessage(Message message, TransactionFlowOption txFlowOption)
{
TransactionInfo transactionInfo = null;
try
{
transactionInfo = this.formatter.ReadTransaction(message);
}
catch (TransactionException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Error);
this.FaultOnMessage(message, System.ServiceModel.SR.GetString("SFxTransactionDeserializationFailed", new object[] { exception.Message }), "TransactionHeaderMalformed");
}
if (transactionInfo != null)
{
TransactionMessageProperty.Set(transactionInfo, message);
}
else if (txFlowOption == TransactionFlowOption.Mandatory)
{
this.FaultOnMessage(message, System.ServiceModel.SR.GetString("SFxTransactionFlowRequired"), "TransactionHeaderMissing");
}
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
TransactionFlowBindingElement element = context.BindingElements.Find <TransactionFlowBindingElement>();
if ((element != null) && element.Transactions)
{
XmlDocument doc = new XmlDocument();
XmlElement item = null;
foreach (OperationDescription description in context.Contract.Operations)
{
TransactionFlowAttribute attribute = description.Behaviors.Find <TransactionFlowAttribute>();
TransactionFlowOption option = (attribute == null) ? TransactionFlowOption.NotAllowed : attribute.Transactions;
if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.OleTransactions)
{
item = this.GetAssertion(doc, option, "oletx", "OleTxAssertion", "http://schemas.microsoft.com/ws/2006/02/tx/oletx", exporter.PolicyVersion.Namespace);
}
else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransactionOctober2004)
{
item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://schemas.xmlsoap.org/ws/2004/10/wsat", exporter.PolicyVersion.Namespace);
}
else if (element.TransactionProtocol == System.ServiceModel.TransactionProtocol.WSAtomicTransaction11)
{
item = this.GetAssertion(doc, option, "wsat", "ATAssertion", "http://docs.oasis-open.org/ws-tx/wsat/2006/06", exporter.PolicyVersion.Namespace);
}
if (item != null)
{
context.GetOperationBindingAssertions(description).Add(item);
}
}
}
}
void ReadTransactionFromMessage(Message message, TransactionFlowOption txFlowOption)
{
TransactionInfo transactionInfo = null;
try
{
transactionInfo = this.formatter.ReadTransaction(message);
}
catch (TransactionException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
FaultOnMessage(message, SR.GetString(SR.SFxTransactionDeserializationFailed, e.Message), FaultCodeConstants.Codes.TransactionHeaderMalformed);
}
if (transactionInfo != null)
{
TransactionMessageProperty.Set(transactionInfo, message);
}
else if (txFlowOption == TransactionFlowOption.Mandatory)
{
FaultOnMessage(message, SR.GetString(SR.SFxTransactionFlowRequired), FaultCodeConstants.Codes.TransactionHeaderMissing);
}
}
public TransactionFlowAttribute(TransactionFlowOption transactions)
{
Transactions = transactions;
}
public XmlElement GetAssertion (XmlDocument doc,
TransactionFlowOption option,
string prefix, string name, string ns)
{
throw new NotImplementedException ();
}
public TransactionFlowAttribute(TransactionFlowOption transactions)
{
TransactionFlowBindingElement.ValidateOption(transactions);
this.transactions = transactions;
}
public TransactionFlowAttribute (TransactionFlowOption transactions)
{
Transactions = transactions;
}
public GenericTransactionFlowAttribute(TransactionFlowOption flowOption)
{
this.transactionFlowAttribute = new TransactionFlowAttribute(flowOption);
}
void UpdateTransactionFlowAtribute(OperationDescription operation, TransactionFlowOption txFlow)
{
operation.Behaviors.Remove<TransactionFlowAttribute>();
operation.Behaviors.Add(new TransactionFlowAttribute(txFlow));
}
static void TrackAgreement(ref bool everyoneAgrees, TransactionFlowOption option,
ref TransactionFlowOption agreedOption, ref bool anOperationCares)
{
if (!anOperationCares)
{
// this is the first operation to express a preference
agreedOption = option;
anOperationCares = true;
// everyoneAgrees is still true
}
else
{
if (option != agreedOption)
everyoneAgrees = false;
}
}
public TransactionFlowAttribute(TransactionFlowOption transactions)
{
TransactionFlowBindingElement.ValidateOption(transactions);
_transactions = transactions;
}
