internal static EntitySnapshot <T> SetProviderAliasOnId <T>(ProviderMetadata providerMetadata, EntitySnapshot <T> entity) where T : class, IVersionableEntity
{
if (entity == null)
{
return(null);
}
SetProviderAliasOnId(providerMetadata, entity.Revision);
return(entity);
}
protected AbstractSchemaRepositoryFactory(
ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory <EntitySchema> revisionRepositoryFactory,
IFrameworkContext frameworkContext,
ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, revisionRepositoryFactory, frameworkContext, dependencyHelper)
{
RevisionRepositoryFactory = revisionRepositoryFactory;
}
public void RegisterProvider(string systemName, IProvider provider)
{
var metadata = new ProviderMetadata
{
SystemName = systemName
};
_providers[metadata] = provider;
}
public DependencyHelper(
IEnumerable <ProviderElement> configuredProviders,
Lazy <IEnumerable <MembershipProvider> > membershipProviders,
ProviderMetadata providerMetadata)
: base(providerMetadata)
{
MembershipProviders = membershipProviders;
ConfiguredProviders = configuredProviders;
}
protected AbstractRevisionRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext)
: base(providerMetadata, frameworkContext)
{
CanWrite = true;
Transaction = providerTransaction;
//RevisionDataAddedOrUpdated = new HashSet<RevisionData>();
//EntityDataAddedOrUpdated = new HashSet<T>();
RevisionsAddedOrUdpated = new HashSet <IRevision <IVersionableEntity> >();
}
protected AbstractProviderRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
{
CanRead = true;
ProviderMetadata = providerMetadata;
FrameworkContext = frameworkContext;
RepositoryScopedCache = new DictionaryScopedCache();
//HiveContext = new RepositoryContext(RuntimeCacheProvider.Default, PerHttpRequestCacheProvider.Default, frameworkContext);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="providerMetadata"></param>
/// <param name="revisionRepositoryFactory"></param>
/// <param name="schemaRepositoryFactory"></param>
/// <param name="frameworkContext"></param>
/// <param name="dependencyHelper"></param>
public EntityRepositoryFactory(
ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory <TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext,
ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, dependencyHelper)
{
}
/// <summary>
/// Internal constructor for testing
/// </summary>
/// <param name="providerMetadata"></param>
/// <param name="revisionRepositoryFactory"></param>
/// <param name="schemaRepositoryFactory"></param>
/// <param name="frameworkContext"></param>
/// <param name="helper"></param>
internal EntityRepositoryFactory(
ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory <TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext,
ExamineHelper helper)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(helper, providerMetadata))
{
}
/// <summary>
/// Gets provider data for the specified provider.
/// </summary>
/// <param name="providerName">The name of the provider.</param>
/// <returns>A String with info.</returns>
public static String getEventProvider(String providerName)
{
EventLogSession session = new EventLogSession();
String providerMessageFilePath = String.Empty;
String providerParameterFilePath = String.Empty;
String providerResourceFileName = String.Empty;
String providerHelpLink = String.Empty;
String providerDisplayName = String.Empty;
//IList<EventLogLink> eventLogLinks = null;
StringBuilder sb = new StringBuilder();
try {
sb.AppendLine("Provider: " + providerName);
ProviderMetadata metaData = new ProviderMetadata(providerName, //Provider name to look up
session, //The session
CultureInfo.CurrentCulture); //Culture of active thread
if (metaData != null)
{
providerDisplayName = metaData.DisplayName; //Display Name of the provider
if (metaData.HelpLink != null)
{
providerHelpLink = metaData.HelpLink.ToString(); //Link to external help on event
}
providerMessageFilePath = metaData.MessageFilePath; //Source of provider metadata
providerParameterFilePath = metaData.ParameterFilePath; //Source of provider metadata
providerResourceFileName = metaData.ResourceFilePath; //Resource with provider metadata
//eventLogLinks = metaData.LogLinks;
}
//sb.AppendLine("HelpLink: " + providerHelpLink);
//sb.AppendLine("MessageFilePath: " + providerMessageFilePath);
//sb.AppendLine("ParameterFilePath: " + providerParameterFilePath);
//sb.AppendLine("ResourceFilePath: " + providerResourceFileName);
sb.AppendLine();
sb.AppendLine("This provider has the following logs:");
foreach (EventLogLink eventLink in metaData.LogLinks)
{
sb.AppendLine(SEPARATOR_LINE);
sb.AppendFormat("Display Name: {0}", eventLink.DisplayName);
sb.AppendFormat("LogName: {0}", eventLink.LogName);
}
sb.AppendLine();
sb.AppendLine("This provider publishes the following events:");
foreach (EventMetadata eventData in metaData.Events)
{
sb.AppendLine(SEPARATOR_LINE);
sb.AppendFormat("Event ID = {0}. Description: {1}",
eventData.Id, eventData.Description);
}
} catch (Exception ex) {
sb.Append(Utils.excMsg("Error in getEventProviders", ex));
}
return(sb.ToString());
}
internal static Revision <T> SetProviderAliasOnId <T>(ProviderMetadata providerMetadata, Revision <T> entity) where T : class, IVersionableEntity
{
if (entity == null)
{
return(null);
}
SetProviderAliasOnId(providerMetadata, entity.Item);
SetProviderAliasOnId(providerMetadata, entity.MetaData);
return(entity);
}
protected AbstractReadonlyEntityRepositoryFactory(ProviderMetadata providerMetadata,
AbstractReadonlySchemaRepositoryFactory schemaRepositoryFactory,
AbstractReadonlyRevisionRepositoryFactory <TypedEntity> revisionRepositoryFactory,
IFrameworkContext frameworkContext,
ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, frameworkContext, dependencyHelper)
{
SchemaRepositoryFactory = schemaRepositoryFactory;
RevisionRepositoryFactory = revisionRepositoryFactory;
}
//public SchemaRepositoryFactory MembershipSchemaRepositoryFactory { get { return base.SchemaRepositoryFactory as SchemaRepositoryFactory; } }
/// <summary>
/// Internal constructor for testing
/// </summary>
/// <param name="providerMetadata"></param>
/// <param name="revisionRepositoryFactory"></param>
/// <param name="schemaRepositoryFactory"></param>
/// <param name="frameworkContext"></param>
/// <param name="membershipProviders"></param>
/// <param name="configuredProviders"></param>
internal EntityRepositoryFactory(
ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory <TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext,
Lazy <IEnumerable <MembershipProvider> > membershipProviders,
IEnumerable <ProviderElement> configuredProviders)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(configuredProviders, membershipProviders, providerMetadata))
{
}
protected void AssignFakeIdsIfPassthrough <T>(ProviderMetadata providerMetadata, params Revision <T>[] revision)
where T : class, IVersionableEntity
{
revision.ForEach(
x =>
{
AssignFakeIdsIfPassthrough(providerMetadata, x.Item);
AssignFakeIdsIfPassthrough(providerMetadata, x.MetaData);
});
}
public RevisionRepository(
ProviderMetadata providerMetadata,
IProviderTransaction providerTransaction,
IFrameworkContext frameworkContext,
ExamineHelper helper)
: base(providerMetadata, providerTransaction, frameworkContext)
{
Helper = helper;
ExamineTransaction = providerTransaction as ExamineTransaction;
}
/// <summary>
/// Initializes a new instance of the CreateCheckoutSessionRequest class.
/// </summary>
/// <param name="checkoutReviewReturnUrl">Checkout review URL provided by the merchant. Amazon Pay will redirect to this URL after the buyer selects their preferred payment instrument and shipping address.</param>
/// <param name="storeId">Store ID as defined in Seller Central.</param>
public CreateCheckoutSessionRequest(string checkoutReviewReturnUrl, string storeId)
{
WebCheckoutDetails = new WebCheckoutDetails();
DeliverySpecifications = new DeliverySpecifications();
PaymentDetails = new PaymentDetails();
MerchantMetadata = new MerchantMetadata();
ProviderMetadata = new ProviderMetadata();
WebCheckoutDetails.CheckoutReviewReturnUrl = checkoutReviewReturnUrl;
StoreId = storeId;
}
public string GetIconUrl(ProviderMetadata metadata)
{
var plugin = metadata.PluginDescriptor;
if (plugin == null)
{
return(GetDefaultIconUrl(metadata.GroupName));
}
return(GetIconUrl(plugin, metadata.SystemName));
}
public CheckoutSessionResponse()
{
WebCheckoutDetails = new WebCheckoutDetails();
PaymentDetails = new PaymentDetails();
MerchantMetadata = new MerchantMetadata();
Buyer = new Buyer();
ProviderMetadata = new ProviderMetadata();
ShippingAddress = new Address();
PaymentPreferences = new List <PaymentPreferences>();
Constraints = new List <Constraint>();
}
public static IList <EventKeyword> GetEventKeyword(string computerName, string provider)
{
try
{
using (var session = GetEventLogSession(computerName))
using (var meta = new ProviderMetadata(provider, session, CultureInfo.CurrentUICulture))
return(meta.Keywords);
}
catch { }
return(null);
}
/// <summary>
/// Retrieves event data from the system based on event metadata.
/// </summary>
/// <returns>A list of events.</returns>
public static IList <EventData> GetEvents()
{
IList <EventData> events = new List <EventData>();
using (EventLogSession session = new EventLogSession())
{
foreach (string providerName in session.GetProviderNames())
{
ProviderMetadata provider = null;
try
{
provider = new ProviderMetadata(providerName);
string provName = providerName; // prevents "Access to foreach variable in a closure" warning
foreach (EventData eventData in provider.Events.Select(eventMetadata => new EventData(provName, eventMetadata)).Where(eventData => !events.Contains(eventData)))
{
events.Add(eventData);
}
}
catch (EventLogNotFoundException elnfe)
{
// Microsoft-Windows-TerminalServices-ServerUSBDevice = The system cannot find the file specified.
// Microsoft-Windows-WPD-MTPClassDriver = The system cannot find the file specified
// Microsoft-Windows-Sdbus-SQM = The system cannot find the files specified
Logger.Error(elnfe, CultureInfo.CurrentCulture, "Event provider '{0}' not found while processing events: {1}{2}{3}", providerName, elnfe.Message, Environment.NewLine, elnfe.StackTrace);
}
catch (EventLogException ele)
{
// Microsoft-Windows-MsiServer = The specified resource type cannot be found in the image file
// Microsoft-Windows-CAPI2 = The data is invalid
Logger.Error(ele, CultureInfo.CurrentCulture, "Event provider '{0}' threw a generic event log exception while processing events: {1}{2}{3}", providerName, ele.Message, Environment.NewLine, ele.StackTrace);
}
catch (UnauthorizedAccessException uae)
{
// thrown when running as a normal user and accessing these:
// Microsoft-Windows-Security-Auditing
// Microsoft-Windows-Eventlog
Logger.Error(uae, CultureInfo.CurrentCulture, "Access denied to event provider '{0}' while processing events: {1}{2}{3}", providerName, uae.Message, Environment.NewLine, uae.StackTrace);
}
finally
{
provider?.Dispose();
}
}
}
return(events);
}
public EntityRepository(
ProviderMetadata providerMetadata,
IFrameworkContext frameworkContext,
IEnumerable <MembershipProvider> membershipProviders,
IEnumerable <ProviderElement> configuredProviders)
: base(providerMetadata, frameworkContext)
{
var providers = membershipProviders.ToArray();
MembershipProviders = providers;
Helper = new MembershipWrapperHelper(configuredProviders, providers, frameworkContext);
}
public void ProviderMappingGroup_IsMatchForUri(string assertUri, string[] wildcardMatches, bool shouldMatch)
{
// Arrange
var matches = wildcardMatches.Select(x => new WildcardUriMatch(x)).ToList();
var context = new FakeFrameworkContext();
var metadata = new ProviderMetadata("test", new Uri("unimportant://"), true, false);
var readonlySetup = new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0);
var setup = new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0);
var group = new ProviderMappingGroup("default", matches, Enumerable.Repeat(readonlySetup, 1), Enumerable.Repeat(setup, 1), new FakeFrameworkContext());
// Assert
Assert.That(shouldMatch, Is.EqualTo(group.IsMatchForUri(new Uri(assertUri)).Success));
}
public static IList <EventKeyword> GetEventKeyword(string computerName, string provider)
{
bool isLocal = (string.IsNullOrEmpty(computerName) || computerName == "." || computerName.Equals(Environment.MachineName, StringComparison.CurrentCultureIgnoreCase));
try
{
using (EventLogSession session = isLocal ? new EventLogSession() : new EventLogSession(computerName))
using (var meta = new ProviderMetadata(provider, session, System.Globalization.CultureInfo.CurrentUICulture))
return(meta.Keywords);
}
catch { }
return(null);
}
public EntityRepository(
ProviderMetadata providerMetadata,
IProviderTransaction providerTransaction,
IFrameworkContext frameworkContext,
AbstractRevisionRepository <TypedEntity> revisionRepository,
AbstractSchemaRepository schemaSession,
ExamineHelper helper)
: base(providerMetadata, providerTransaction, revisionRepository, schemaSession, frameworkContext)
{
Helper = helper;
ExamineTransaction = providerTransaction as ExamineTransaction;
Mandate.That(ExamineTransaction != null, x => new InvalidCastException("The IProviderTransaction for the Examine EntityRepository must be of Type ExamineTransaction"));
}
internal static IRelationById CreateRelationByIdWithProviderId(ProviderMetadata providerMetadata, IRelationById relation)
{
if (relation == null)
{
return(null);
}
return(new RelationById(
CreateMappedProviderId(providerMetadata, relation.SourceId),
CreateMappedProviderId(providerMetadata, relation.DestinationId),
relation.Type,
relation.Ordinal,
relation.MetaData.ToArray()));
}
public void WhenProviderMetadataIsPassthrough_ProviderId_IsNotSet_OnHiveId()
{
// Arrange
var metadata = new ProviderMetadata("test", new Uri("mappingroot://"), false, true);
var originalId = new HiveId(1);
// Act
var newId = ProviderRepositoryHelper.CreateMappedProviderId(metadata, originalId);
// Assert
Assert.IsNull(newId.ProviderId);
Assert.AreNotEqual(metadata.Alias, newId.ProviderId);
}
public MembershipWrapperTestSetupHelper(FakeFrameworkContext frameworkContext = null)
{
//clear out the Roles/Users xml files for the test membership provider
var current = new DirectoryInfo(Common.CurrentAssemblyDirectory);
while (current.Parent.GetDirectories("App_Data").SingleOrDefault() == null)
{
current = current.Parent;
}
var appData = current.Parent.GetDirectories("App_Data").Single();
foreach (var f in appData.GetFiles("*.xml"))
{
f.Delete();
}
foreach (var f in appData.GetFiles("*.orig"))
{
f.CopyTo(Path.Combine(f.Directory.FullName, Path.GetFileNameWithoutExtension(f.Name) + ".xml"));
}
_fakeFrameworkContext = frameworkContext ?? new FakeFrameworkContext();
var attributeTypeRegistry = new CmsAttributeTypeRegistry();
var mapper = new MembershipWrapperModelMapper(attributeTypeRegistry, _fakeFrameworkContext);
_fakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { mapper, new FrameworkModelMapper(_fakeFrameworkContext) }));
var providerMetadata = new ProviderMetadata("r-unit-tester", new Uri("tester://"), true, false);
//need to reset our custom membership provider before each test
var membershipProvider = global::System.Web.Security.Membership.Providers.Cast <MembershipProvider>().OfType <CustomXmlMembershipProvider>().Single();
membershipProvider.Reset();
var configuredProviders = new List <ProviderElement>(new[] { new ProviderElement()
{
Name = "test", WildcardCharacter = "*"
} });
var revisionSchemaFactory = new NullProviderRevisionRepositoryFactory <EntitySchema>(providerMetadata, _fakeFrameworkContext);
var revisionRepositoryFactory = new NullProviderRevisionRepositoryFactory <TypedEntity>(providerMetadata, _fakeFrameworkContext);
var schemaRepositoryFactory = new NullProviderSchemaRepositoryFactory(providerMetadata, _fakeFrameworkContext);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, _fakeFrameworkContext,
new Lazy <IEnumerable <MembershipProvider> >(() => global::System.Web.Security.Membership.Providers.Cast <MembershipProvider>()),
configuredProviders);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, providerMetadata, _fakeFrameworkContext, null, 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, _fakeFrameworkContext, null, 0);
}
/// <summary>
/// Make fake discovery for authorization
/// </summary>
/// <param name="clientId">Client id</param>
/// <param name="clientSecret">Client secret</param>
/// <param name="subscriberId">Subscriber ID</param>
/// <param name="appName">Client application name</param>
/// <param name="operatorsUrl">Operators urls</param>
/// <returns>Generated fake discovery response</returns>
public async Task <DiscoveryResponse> MakeDiscoveryForAuthorization(string clientId, string clientSecret, string subscriberId,
string appName, OperatorUrls operatorsUrl)
{
Validate.RejectNullOrEmpty(clientId, "clientId");
Validate.RejectNullOrEmpty(clientSecret, "clientSecret");
Validate.RejectNull(operatorsUrl, "operatorsUrl");
var discoveryService = new DiscoveryService(new ConcurrentCache(), _client);
var providerMetadata = new ProviderMetadata();
var discoveryGenerateResponseOptions = new DiscoveryResponseGenerateOptions(clientSecret, clientId, subscriberId, appName, operatorsUrl.GetListOfUrls(), operatorsUrl.GetListOfRels());
var restResponse = new RestResponse()
{
StatusCode = HttpStatusCode.OK,
Content = discoveryGenerateResponseOptions.GetJsonResponse()
};
try
{
var index = 0;
var length = discoveryGenerateResponseOptions.Response.response.apis.operatorid.link.Count;
for (var i = 0; i < length; i++)
{
if (discoveryGenerateResponseOptions.Response.response.apis.operatorid.link[i].rel != LinkRels.OPENID_CONFIGURATION)
{
continue;
}
index = i;
break;
}
var providerMetadataLink = discoveryGenerateResponseOptions.Response.response.apis.operatorid.link[index].href;
if (providerMetadataLink != null)
{
providerMetadata = await discoveryService.RetrieveProviderMetada(providerMetadataLink);
}
}
catch (Exception exception)
{
throw exception;
}
var discoveryResponse = new DiscoveryResponse(restResponse);
discoveryResponse.ProviderMetadata = providerMetadata;
return(discoveryResponse);
}
public void IsSupportedPCRShouldReturnTrueIfSupportedVersionIs1_2()
{
var metadata = new ProviderMetadata
{
MobileConnectVersionSupported = new SupportedVersions(new Dictionary <string, string> {
["openid"] = "mc_v1.2"
}),
LoginHintMethodsSupported = null,
};
var actual = LoginHint.IsSupportedForMsisdn(metadata);
Assert.IsTrue(actual);
}
public void WhenProviderMetadataIsNotPassthrough_ButProviderIdIsAlreadySet_ProviderId_IsNotOverriden_OnHiveId()
{
// Arrange
var metadata = new ProviderMetadata("test", new Uri("mappingroot://"), false, false);
var originalId = new HiveId(new Uri("myroot://"), "myprovider", new HiveIdValue(1));
// Act
var newId = ProviderRepositoryHelper.CreateMappedProviderId(metadata, originalId);
// Assert
Assert.NotNull(newId.ProviderId);
Assert.AreNotEqual(metadata.Alias, newId.ProviderId);
Assert.AreEqual(originalId.ProviderId, newId.ProviderId);
}
protected virtual void SetUserData(ProviderMetadata metadata)
{
if (!metadata.IsEditable)
{
return;
}
var displayOrder = string.Empty;
var name = string.Empty;
var description = string.Empty;
metadata.FriendlyName = name;
metadata.Description = description;
}