/// <summary>
/// Makes the plural.
/// </summary>
/// <param name="word">The word.</param>
/// <returns></returns>
public static string MakePlural(string word)
{
try
{
if (string.IsNullOrEmpty(word))
{
return(string.Empty);
}
if (PluralizationService == null)
{
return(word);
}
if (word.Contains('_'))
{
return(MakePluralHelper(word, '_'));
}
if (word.Contains(' '))
{
return(MakePluralHelper(word, ' '));
}
if (word.Contains('-'))
{
return(MakePluralHelper(word, '-'));
}
return(PluralizationService.Pluralize(word));
}
catch (Exception)
{
return(word);
}
}
public IConfiguration Discover(EntitySet entitySet, DbModel model)
{
Debug.Assert(entitySet != null, "entitySet is null.");
Debug.Assert(model != null, "model is null.");
var storeEntitySet = model.ConceptualToStoreMapping
.EntitySetMappings.First(m => m.EntitySet == entitySet)
.EntityTypeMappings.First()
.Fragments.First()
.StoreEntitySet;
var tableName = storeEntitySet.GetStoreModelBuilderMetadataProperty("Name")
?? storeEntitySet.Table
?? storeEntitySet.Name;
var schemaName = storeEntitySet.GetStoreModelBuilderMetadataProperty("Schema") ?? storeEntitySet.Schema;
if (_pluralizationService.Pluralize(_code.Type(entitySet.ElementType)) == tableName &&
(string.IsNullOrEmpty(schemaName) || schemaName == "dbo"))
{
// By convention
return(null);
}
return(new TableConfiguration {
Table = tableName, Schema = schemaName != "dbo" ? schemaName : null
});
}
private static string GetTableName(Type xType, string xPrefix)
{
IPluralizationService pluralizationService = DbConfiguration.DependencyResolver.GetService <IPluralizationService>();
string result = pluralizationService.Pluralize(xType.Name);
return($"{xPrefix}_{result}");
}
public void Add(ObjectElement obj, IEnumerable <ColumnElement> columns)
{
var className = SafeName(string.IsNullOrEmpty(obj.ClassName) ? obj.Name : obj.ClassName);
var propertyName = SafeName(string.IsNullOrEmpty(obj.PropertyName) ? obj.Name : obj.PropertyName);
if (IsPluralize)
{
className = Pluralization.Singularize(className);
propertyName = Pluralization.Pluralize(propertyName);
}
var objectGenerator = new ClassGenerator(obj)
{
ClassName = className,
PropertyName = propertyName
};
foreach (var column in columns)
{
var name = SafeName(string.IsNullOrEmpty(column.PropertyName) ? column.Name : column.PropertyName);
if (objectGenerator.ClassName == name)
{
name += CharIndex;
}
var memberGenerator = new MemberGenerator(column, name);
objectGenerator.Members.Add(column.Name, memberGenerator);
}
Objects.Add(obj.Key, objectGenerator);
}
private static string GetNavigationPropertyName(IPluralizationService service, AssociationEndMember toEnd, string storeTableName)
{
return(service == null
? storeTableName
: toEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many
? service.Pluralize(storeTableName)
: service.Singularize(storeTableName));
}
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();
}
/// <summary>
/// Makes the plural.
/// </summary>
/// <param name="word">The word.</param>
/// <returns></returns>
public static string MakePlural(string word)
{
try
{
return((PluralizationService == null) ? word : PluralizationService.Pluralize(word));
}
catch (Exception)
{
return(word);
}
}
private void ConfigureDerivedEntity <TEntity>(DbModelBuilder modelBuilder) where TEntity : TimestampedEntity
{
modelBuilder.Entity <TEntity>().HasKey(e => e.Id);
modelBuilder.Entity <TEntity>().Property(e => e.Id).HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
modelBuilder.Entity <TEntity>().HasRequired(e => e.Creator).WithMany().HasForeignKey(e => e.CreatorId);
modelBuilder.Entity <TEntity>().HasOptional(e => e.Amender).WithMany().HasForeignKey(e => e.AmenderId);
modelBuilder.Entity <TEntity>().Map(m =>
{
m.MapInheritedProperties();
m.ToTable(_pluralizationService.Pluralize(typeof(TEntity).Name));
});
}
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")));
}
/// <inheritdoc />
public virtual void Apply(EntitySet item, DbModel model)
{
Check.NotNull(item, "item");
Check.NotNull(model, "model");
if (item.GetConfiguration() == null)
{
item.Name
= model.GetConceptualModel().GetEntitySets()
.Except(new[] { item })
.UniquifyName(_pluralizationService.Pluralize(item.Name));
}
}
public void Apply(EntitySet edmDataModelItem, EdmModel model)
{
Check.NotNull(edmDataModelItem, "edmDataModelItem");
Check.NotNull(model, "model");
if (edmDataModelItem.GetConfiguration() == null)
{
edmDataModelItem.Name
= model.GetEntitySets()
.Except(new[] { edmDataModelItem })
.UniquifyName(_pluralizationService.Pluralize(edmDataModelItem.Name));
}
}
public static string Pluralize(string word)
{
// if known plural, return unchanged
if (KnownPlural.ContainsKey(word))
{
return(word);
}
// if in singular-to-plural, return plural
return(SingularToPlural
.TryGetValue(word, out var plural)
? plural
: PluralizationService.Pluralize(word));
}
protected virtual string GetControllerName(ControllerModel controller)
{
if (controller.RouteValues.ContainsKey("controller"))
{
return(controller.RouteValues["controller"]);
}
var controllerName = pluralizationService.Pluralize(controller.ControllerName);
if (aspNetCoreOptions.Routes.UseKebapCase)
{
return(controllerName.ToKebabCase());
}
;
return(controllerName);
}
/// <summary>
/// This method first checks if the type has a [JsonObject] attribute. If so,
/// it uses the attribute's Title. Otherwise it falls back to pluralizing the
/// type's name using the given <see cref="IPluralizationService" /> and then
/// dasherizing that value.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public virtual string GetResourceTypeNameForType(Type type)
{
var jsonObjectAttribute = type.GetCustomAttributes().OfType <JsonObjectAttribute>().FirstOrDefault();
string title = null;
if (jsonObjectAttribute != null)
{
title = jsonObjectAttribute.Title;
}
if (string.IsNullOrEmpty(title))
{
title = GetNameForType(type);
}
return(_pluralizationService.Pluralize(title).Dasherize());
}
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));
}
}
// internal for testing
internal void GenerateEntitySet(
SimpleMappingContext mappingContext,
EntitySet storeEntitySet,
UniqueIdentifierService uniqueEntityContainerNames,
UniqueIdentifierService globallyUniqueTypeNames)
{
Debug.Assert(mappingContext != null, "mappingContext != null");
Debug.Assert(storeEntitySet != null, "storeEntitySet != null");
Debug.Assert(uniqueEntityContainerNames != null, "uniqueEntityContainerNames != null");
Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null");
var conceptualEntityType = GenerateEntityType(mappingContext, storeEntitySet.ElementType, globallyUniqueTypeNames);
var conceptualEntitySetName = CreateModelName(
(_pluralizationService != null) ? _pluralizationService.Pluralize(storeEntitySet.Name) : storeEntitySet.Name,
uniqueEntityContainerNames);
var conceptualEntitySet = EntitySet.Create(conceptualEntitySetName, null, null, null, conceptualEntityType, null);
mappingContext.AddMapping(storeEntitySet, conceptualEntitySet);
}
private static string GetNavigationPropertyName(IPluralizationService service, AssociationEndMember toEnd, string storeTableName)
{
return service == null
? storeTableName
: toEnd.RelationshipMultiplicity == RelationshipMultiplicity.Many
? service.Pluralize(storeTableName)
: service.Singularize(storeTableName);
}
private string GetPluralizedName()
{
var className = typeof(T).Name;
return(pluralizationService.Pluralize(className));
}
public string Pluralize(string input)
{
return(pluralizationService.Pluralize(input));
}
public static string Pluralize(string word)
{
return(PluralizationService.Pluralize(word));
}
public static string Pluralize(this string name)
{
return(pluralizationService.Pluralize(name)); // remove EF type suffix, if any
}
static string Pluralize(string word, bool pluralize)
{
return(pluralize? pluralizationService.Pluralize(word) : word);
}
