public ConnectionsController(
IQueryable<Participant> participantRepository,
IPluralizationService pluralizationService)
{
this.participantRepository = participantRepository;
this.pluralizationService = pluralizationService;
}
protected internal void SetPluralizationService(IPluralizationService pluralizationService)
{
Check.NotNull(pluralizationService, "pluralizationService");
_internalConfiguration.CheckNotLocked("SetPluralizationService");
_internalConfiguration.RegisterSingleton(pluralizationService);
}
private static string GetTableName(Type xType, string xPrefix)
{
IPluralizationService pluralizationService = DbConfiguration.DependencyResolver.GetService <IPluralizationService>();
string result = pluralizationService.Pluralize(xType.Name);
return($"{xPrefix}_{result}");
}
public SchemaProvider(IColumnSchemaServiceFactory columnSchemaServiceFactory,
IPrimaryKeySchemaServiceFactory primaryKeySchemaServiceFactory,
ITableSchemaService tableSchemaService,
IColumnTypeSchemaService columnTypeSchemaService,
IDbTypeService dbTypeService,
IAssociationSchemaService associationSchemaService,
IPluralizationService pluralizationService,
IPropertyNameDeDuplicateService propertyNameDeDuplicateService)
{
ArgumentUtility.CheckNotNull("columnSchemaServiceFactory", columnSchemaServiceFactory);
ArgumentUtility.CheckNotNull("primaryKeySchemaServiceFactory", primaryKeySchemaServiceFactory);
ArgumentUtility.CheckNotNull("tableSchemaService", tableSchemaService);
ArgumentUtility.CheckNotNull("columnTypeSchemaService", columnTypeSchemaService);
ArgumentUtility.CheckNotNull("dbTypeService", dbTypeService);
ArgumentUtility.CheckNotNull("associationSchemaService", associationSchemaService);
ArgumentUtility.CheckNotNull("pluralizationService", pluralizationService);
ArgumentUtility.CheckNotNull("propertyNameDeDuplicateService", propertyNameDeDuplicateService);
this._columnSchemaServiceFactory = columnSchemaServiceFactory;
this._primaryKeySchemaServiceFactory = primaryKeySchemaServiceFactory;
this._tableSchemaService = tableSchemaService;
this._dbTypeService = dbTypeService;
this._associationSchemaService = associationSchemaService;
this._propertyNameDeDuplicateService = propertyNameDeDuplicateService;
this._columnTypes = columnTypeSchemaService.GetSchema();
this._pluralizationService = pluralizationService;
}
private static string GetNavigationPropertyName(IPluralizationService service, AssociationEndMember toEnd, string storeTableName)
{
return(service == null
? storeTableName
: toEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many
? service.Pluralize(storeTableName)
: service.Singularize(storeTableName));
}
// Internal for testing
internal TableDiscoverer(CodeHelper code, IPluralizationService pluralizationService)
{
Debug.Assert(code != null, "code is null.");
Debug.Assert(pluralizationService != null, "pluralizationService is null.");
_code = code;
_pluralizationService = pluralizationService;
}
// Internal for testing
internal TableDiscoverer(CodeHelper code, IPluralizationService pluralizationService)
{
Debug.Assert(code != null, "code is null.");
Debug.Assert(pluralizationService != null, "pluralizationService is null.");
_code = code;
_pluralizationService = pluralizationService;
}
private void Init(IUserContext userContext)
{
_userContext = userContext;
Database.Log = (s) => Trace.Write(s);
Configuration.LazyLoadingEnabled = false;
_pluralizationService = new EnglishPluralizationService();
var dependency = typeof(System.Data.Entity.SqlServer.SqlFunctions); // Create a reference to System.Data.Entity.SqlServer so that the DLL gets published to bin.
}
public DataTableNameConvention(
IPluralizationService pluralizationService,
IDictionary <string, string> explicitNames)
{
Types().Configure(
c => c.ToTable(
GetName(c.ClrType, pluralizationService, explicitNames))
);
}
public Table(TableSchema schema, IPluralizationService pluralizationService)
{
ArgumentUtility.CheckNotNull("schema", schema);
ArgumentUtility.CheckNotNull("pluralizationService", pluralizationService);
this.TableName = schema.TableName;
this.EntityName = pluralizationService.Singularize(schema.TableName).ToSafeClrName();
this.IsView = schema.IsView;
}
public MediaItemsController(
IQueryable<Participant> participantRepository,
IQueryable<MediaItem> mediaItemRepository,
IPluralizationService pluralizationService)
{
this.participantRepository = participantRepository;
this.mediaItemRepository = mediaItemRepository;
this.pluralizationService = pluralizationService;
}
public MongoRepository(IRepositorySettings _settings, IPluralizationService _pluralizationService)
{
settings = _settings;
pluralizationService = _pluralizationService;
conn = _settings.GetClientConnection();
db = settings.GetDatabase();
collection = db.GetCollection <T>(pluralizationService.Pluralize(typeof(T).Name));
collectionQueryable = collection.AsQueryable();
}
internal static Association CreateAssociationAndAssociationSetWithDefaultNames(
CommandProcessorContext cpc, ConceptualEntityType end1Entity, ConceptualEntityType end2Entity)
{
var service = cpc.EditingContext.GetEFArtifactService();
var artifact = service.Artifact;
// the model that we want to add the association to
var model = artifact.ConceptualModel();
if (model == null)
{
throw new CannotLocateParentItemException();
}
// Should have discovered the association name through the behavior service. Going back to default
var associationName = ModelHelper.GetUniqueName(
typeof(Association), model, end1Entity.LocalName.Value + end2Entity.LocalName.Value);
// pluralization service is based on English only for Dev10
IPluralizationService pluralizationService = null;
var pluralize = ModelHelper.GetDesignerPropertyValueFromArtifactAsBool(
OptionsDesignerInfo.ElementName,
OptionsDesignerInfo.AttributeEnablePluralization, OptionsDesignerInfo.EnablePluralizationDefault, artifact);
if (pluralize)
{
pluralizationService = DependencyResolver.GetService <IPluralizationService>();
}
var end1Multiplicity = ModelConstants.Multiplicity_One;
var end2Multiplicity = ModelConstants.Multiplicity_Many;
var proposedEnd1NavPropName = ModelHelper.ConstructProposedNavigationPropertyName(
pluralizationService, end2Entity.LocalName.Value, end2Multiplicity);
var end1NavigationPropertyName = ModelHelper.GetUniqueConceptualPropertyName(proposedEnd1NavPropName, end1Entity);
var proposedEnd2NavPropName = ModelHelper.ConstructProposedNavigationPropertyName(
pluralizationService, end1Entity.LocalName.Value, end1Multiplicity);
var end2NavigationPropertyName = ModelHelper.GetUniqueConceptualPropertyName(
proposedEnd2NavPropName, end2Entity, new HashSet <string> {
end1NavigationPropertyName
});
var cac = new CreateConceptualAssociationCommand(
associationName,
end1Entity, end1Multiplicity, end1NavigationPropertyName,
end2Entity, end2Multiplicity, end2NavigationPropertyName,
false, // uniquify names
false); // create foreign key properties
var cp = new CommandProcessor(cpc, cac);
cp.Invoke();
return(cac.CreatedAssociation);
}
public SignatureEntitySetInitializer(
IMetadataService metadataService,
IPluralizationService pluralizationService,
IFactonQueryService factonQueryService,
IQueryBuilderFactory queryBuilderFactory)
{
this.metadataService = metadataService;
this.pluralizationService = pluralizationService;
this.factonQueryService = factonQueryService;
this.queryBuilderFactory = queryBuilderFactory;
}
public DefaultRouteModelConvention(
IOptions <AspNetCoreOptions> aspNetCoreOptions,
IOptions <MultiTenancyOptions> multiTenancyOptions,
IOptions <RouteTenantResolverOptions> routeTenantResolverOptions,
IPluralizationService pluralizationService,
ILogger <IRouteModelConvention> logger)
{
this.multiTenancyOptions = multiTenancyOptions.Value;
this.aspNetCoreOptions = aspNetCoreOptions.Value;
this.routeTenantResolverOptions = routeTenantResolverOptions.Value;
this.pluralizationService = pluralizationService;
this.logger = logger;
}
public OneToOneMappingBuilder(
string namespaceName,
string containerName,
IPluralizationService pluralizationService,
bool generateForeignKeyProperties)
{
Debug.Assert(!string.IsNullOrEmpty(namespaceName), "namespaceName must not be null or empty string");
_namespaceName = namespaceName;
_containerName = containerName;
_pluralizationService = pluralizationService;
_generateForeignKeyProperties = generateForeignKeyProperties;
}
static string GetName(
Type type,
IPluralizationService pluralizationService,
IDictionary <string, string> explicitNames)
{
if (explicitNames.ContainsKey(type.Name))
{
return(explicitNames[type.Name]);
}
return(pluralizationService
.Pluralize(type.Name.TrimEnd("Data")));
}
public OneToOneMappingBuilder(
string namespaceName,
string containerName,
IPluralizationService pluralizationService,
bool generateForeignKeyProperties)
{
Debug.Assert(!string.IsNullOrEmpty(namespaceName), "namespaceName must not be null or empty string");
_namespaceName = namespaceName;
_containerName = containerName;
_pluralizationService = pluralizationService;
_generateForeignKeyProperties = generateForeignKeyProperties;
}
/// <inheritdoc />
public virtual void Apply(EntityType item, DbModel model)
{
Check.NotNull <EntityType>(item, nameof(item));
Check.NotNull <DbModel>(model, nameof(model));
this._pluralizationService = DbConfiguration.DependencyResolver.GetService <IPluralizationService>();
if (item.GetTableName() != null)
{
return;
}
EntitySet entitySet = model.StoreModel.GetEntitySet(item);
entitySet.Table = model.StoreModel.GetEntitySets().Where <EntitySet>((Func <EntitySet, bool>)(es => es.Schema == entitySet.Schema)).Except <EntitySet>((IEnumerable <EntitySet>) new EntitySet[1]
{
entitySet
}).Select <EntitySet, string>((Func <EntitySet, string>)(n => n.Table)).Uniquify(this._pluralizationService.Pluralize(entitySet.Table));
}
public DomainModelProvider(
ISchemaReader schemaReader,
IEntityInfoAdapterFactory entityInfoAdapterFactory,
IPropertyInfoAdapterFactory propertyInfoAdapterFactory,
INavigationPropertyInfoAdapterFactory navigationPropertyInfoAdapterFactory,
IIIdentifierGenerationServiceFactory identifierGenerationServiceFactory,
IPluralizationService pluralizationService,
IReverseEngineeringConfiguration configuration)
{
this.schemaReader = schemaReader;
this.entityInfoAdapterFactory = entityInfoAdapterFactory;
this.navigationPropertyInfoAdapterFactory = navigationPropertyInfoAdapterFactory;
this.propertyInfoAdapterFactory = propertyInfoAdapterFactory;
this.configuration = configuration;
this.identifierGenerationService = identifierGenerationServiceFactory.Create(pluralizationService, configuration);
}
public SchemaProvider(ISchemaOptions schemaOptions)
{
ArgumentUtility.CheckNotNull("schemaOptions", schemaOptions);
ArgumentUtility.CheckNotNull("schemaOptions.Database", schemaOptions.Database);
ArgumentUtility.CheckNotNullOrEmpty("schemaOptions.ConnectionString", schemaOptions.ConnectionString);
this._container = ContainerConfigurator.Configure(new UnityContainer(), schemaOptions);
this._tableSchemaProvider = this._container.Resolve <TableSchemaProvider>();
this._associationSchemaProvider = this._container.Resolve <AssociationSchemaProvider>();
this._dbTypeProvider = this._container.Resolve <DbTypeProvider>();
var columnTypeSchemaProvider = this._container.Resolve <ColumnTypeSchemaProvider>();
this._columnTypes = columnTypeSchemaProvider.GetSchema();
this._duplicatePropertyNameResolver = this._container.Resolve <DuplicatePropertyNameResolver>();
this._pluralizationService = this._container.Resolve <PluralizationService>();
}
public void Apply(EntityType dbDataModelItem, EdmModel model)
{
Check.NotNull(dbDataModelItem, "dbDataModelItem");
Check.NotNull(model, "model");
_pluralizationService = DbConfiguration.GetService <IPluralizationService>();
if (dbDataModelItem.GetTableName() == null)
{
var entitySet = model.GetEntitySet(dbDataModelItem);
entitySet.Table
= model.GetEntitySets()
.Where(es => es.Schema == entitySet.Schema)
.Except(new[] { entitySet })
.UniquifyIdentifier(_pluralizationService.Pluralize(entitySet.Table));
}
}
/// <inheritdoc />
public virtual void Apply(EntityType item, DbModel model)
{
Check.NotNull(item, "item");
Check.NotNull(model, "model");
_pluralizationService = DbConfiguration.DependencyResolver.GetService <IPluralizationService>();
if (item.GetTableName() == null)
{
var entitySet = model.StoreModel.GetEntitySet(item);
entitySet.Table
= model.StoreModel.GetEntitySets()
.Where(es => es.Schema == entitySet.Schema)
.Except(new[] { entitySet })
.Select(n => n.Table)
.Uniquify(_pluralizationService.Pluralize(entitySet.Table));
}
}
protected Repository(IDatabaseContextFactory dbContextFactory, IPluralizationService pluralizationService)
{
this.dbContextFactory = dbContextFactory;
this.pluralizationService = pluralizationService;
}
/// <summary>
/// Creates a new DefaultNamingConventions
/// </summary>
/// <param name="pluralizationService"></param>
public DefaultNamingConventions(IPluralizationService pluralizationService)
{
_pluralizationService = pluralizationService;
}
public PlaceRepository(IDatabaseContextFactory dbContextFactory, IPluralizationService pluralizationService) : base(dbContextFactory, pluralizationService)
{
}
public ModelManager(IPluralizationService pluralizationService)
{
_pluralizationService = pluralizationService;
}
public IdentifierGenerationService(IPluralizationService pluralizationService, IReverseEngineeringConfiguration configuration)
{
this.pluralizationService = pluralizationService;
this.configuration = configuration;
}
public SchemaParameterParser(IPluralizationService pluralizationService)
{
this.pluralizationService = pluralizationService;
}
internal NewAssociationDialog(IEnumerable <EntityType> entityTypes, EntityType entity1, EntityType entity2)
{
Debug.Assert(entity1 != null && entity2 != null, "both entity1 and entity2 should be non-null");
// Ensure _foreignKeysSupported is intialized before we initialize UI components.
_foreignKeysSupported =
EdmFeatureManager.GetForeignKeysInModelFeatureState(entity1.Artifact.SchemaVersion)
.IsEnabled();
// pluralization service is based on English only for Dev10
var pluralize = ModelHelper.GetDesignerPropertyValueFromArtifactAsBool(
OptionsDesignerInfo.ElementName,
OptionsDesignerInfo.AttributeEnablePluralization, OptionsDesignerInfo.EnablePluralizationDefault, entity1.Artifact);
if (pluralize)
{
_pluralizationService = DependencyResolver.GetService <IPluralizationService>();
}
InitializeComponent();
// Set the default font to VS shell font.
var vsFont = VSHelpers.GetVSFont(Services.ServiceProvider);
if (vsFont != null)
{
Font = vsFont;
}
foreach (var entityType in entityTypes)
{
entity1ComboBox.Items.Add(entityType);
entity2ComboBox.Items.Add(entityType);
}
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityOne, ModelConstants.Multiplicity_One));
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityZeroOrOne, ModelConstants.Multiplicity_ZeroOrOne));
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityMany, ModelConstants.Multiplicity_Many));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityOne, ModelConstants.Multiplicity_One));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityZeroOrOne, ModelConstants.Multiplicity_ZeroOrOne));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityMany, ModelConstants.Multiplicity_Many));
// set multiplicity and entity values first before adding event handlers, otherwise
// it tries to update the ExplanationText and calculate NavProp names before all
// of the required information is in place
multiplicity1ComboBox.SelectedIndex = 0;
multiplicity2ComboBox.SelectedIndex = 2;
entity1ComboBox.SelectedItem = entity1;
entity2ComboBox.SelectedItem = entity2;
multiplicity1ComboBox.SelectedIndexChanged += multiplicity1ComboBox_SelectedIndexChanged;
multiplicity2ComboBox.SelectedIndexChanged += multiplicity2ComboBox_SelectedIndexChanged;
entity1ComboBox.SelectedIndexChanged += entity1ComboBox_SelectedIndexChanged;
entity2ComboBox.SelectedIndexChanged += entity2ComboBox_SelectedIndexChanged;
// now update the calculated fields
UpdateAssociationName();
UpdateEnd1NavigationPropertyName();
UpdateEnd2NavigationPropertyName();
UpdateExplanationText();
UpdateCreateForeignKeysCheckBox();
cancelButton.BackColor = SystemColors.Control;
cancelButton.ForeColor = SystemColors.ControlText;
okButton.BackColor = SystemColors.Control;
okButton.ForeColor = SystemColors.ControlText;
}
public JsonApiFormatter(IPluralizationService pluralizationService) :
this(new ModelManager(pluralizationService))
{
}
public ModelManager(IPluralizationService pluralizationService)
{
_pluralizationService = pluralizationService;
RegistrationsByName = new Dictionary<string, TypeRegistration>();
RegistrationsByType = new Dictionary<Type, TypeRegistration>();
}
/// <summary>
/// Creates a new DefaultNamingConventions
/// </summary>
/// <param name="pluralizationService"></param>
public DefaultNamingConventions(IPluralizationService pluralizationService)
{
_pluralizationService = pluralizationService;
}
public TournamentRepository(IDatabaseContextFactory dbContextFactory, IPluralizationService pluralizationService) : base(dbContextFactory, pluralizationService)
{
}
public static BuildPass <T> Create(T buildSection, EntityType entityType, EntityHelper entityHelper, BuildSettings settings, IBuilder builder,
List <string> roots, List <string> enumerations, CodeGenerationTools code, IPluralizationService pluralizationService)
{
return(new BuildPass <T>
{
BuildSection = buildSection,
EntityType = entityType,
EntityHelper = entityHelper,
Settings = settings,
Builder = builder,
Roots = roots,
Enumerations = enumerations,
Code = code,
PluralizationService = pluralizationService
});
}
public EntityNameService(IPluralizationService pluralizationService = null)
{
PluralizationService = pluralizationService;
}
private static string GetNavigationPropertyName(IPluralizationService service, AssociationEndMember toEnd, string storeTableName)
{
return service == null
? storeTableName
: toEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many
? service.Pluralize(storeTableName)
: service.Singularize(storeTableName);
}
internal NewAssociationDialog(IEnumerable<EntityType> entityTypes, EntityType entity1, EntityType entity2)
{
Debug.Assert(entity1 != null && entity2 != null, "both entity1 and entity2 should be non-null");
// Ensure _foreignKeysSupported is intialized before we initialize UI components.
_foreignKeysSupported =
EdmFeatureManager.GetForeignKeysInModelFeatureState(entity1.Artifact.SchemaVersion)
.IsEnabled();
// pluralization service is based on English only for Dev10
var pluralize = ModelHelper.GetDesignerPropertyValueFromArtifactAsBool(
OptionsDesignerInfo.ElementName,
OptionsDesignerInfo.AttributeEnablePluralization, OptionsDesignerInfo.EnablePluralizationDefault, entity1.Artifact);
if (pluralize)
{
_pluralizationService = DependencyResolver.GetService<IPluralizationService>();
}
InitializeComponent();
// Set the default font to VS shell font.
var vsFont = VSHelpers.GetVSFont(Services.ServiceProvider);
if (vsFont != null)
{
Font = vsFont;
}
foreach (var entityType in entityTypes)
{
entity1ComboBox.Items.Add(entityType);
entity2ComboBox.Items.Add(entityType);
}
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityOne, ModelConstants.Multiplicity_One));
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityZeroOrOne, ModelConstants.Multiplicity_ZeroOrOne));
multiplicity1ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityMany, ModelConstants.Multiplicity_Many));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityOne, ModelConstants.Multiplicity_One));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityZeroOrOne, ModelConstants.Multiplicity_ZeroOrOne));
multiplicity2ComboBox.Items.Add(
new MultiplicityComboBoxItem(Resources.PropertyWindow_Value_MultiplicityMany, ModelConstants.Multiplicity_Many));
// set multiplicity and entity values first before adding event handlers, otherwise
// it tries to update the ExplanationText and calculate NavProp names before all
// of the required information is in place
multiplicity1ComboBox.SelectedIndex = 0;
multiplicity2ComboBox.SelectedIndex = 2;
entity1ComboBox.SelectedItem = entity1;
entity2ComboBox.SelectedItem = entity2;
multiplicity1ComboBox.SelectedIndexChanged += multiplicity1ComboBox_SelectedIndexChanged;
multiplicity2ComboBox.SelectedIndexChanged += multiplicity2ComboBox_SelectedIndexChanged;
entity1ComboBox.SelectedIndexChanged += entity1ComboBox_SelectedIndexChanged;
entity2ComboBox.SelectedIndexChanged += entity2ComboBox_SelectedIndexChanged;
// now update the calculated fields
UpdateAssociationName();
UpdateEnd1NavigationPropertyName();
UpdateEnd2NavigationPropertyName();
UpdateExplanationText();
UpdateCreateForeignKeysCheckBox();
}
public JsonApiFormatter(IPluralizationService pluralizationService) :
this(new ModelManager(pluralizationService))
{
}
public SchemaParameterParser(IPluralizationService pluralizationService)
{
this.pluralizationService = pluralizationService;
}
/// <summary>
/// Creates a new JsonApiConfiguration
/// </summary>
public JsonApiConfiguration(IPluralizationService pluralizationService)
: this(new DefaultNamingConventions(pluralizationService))
{
}
public IIdentifierGenerationService Create(IPluralizationService pluralizationService,IReverseEngineeringConfiguration configuration)
{
return new IdentifierGenerationService(pluralizationService, configuration);
}
