/// <summary>
/// Gets the entity framework connection string.
/// </summary>
/// <param name="contextType">Type of the context.</param>
/// <param name="connectionString">The connection string.</param>
/// <returns>The entity framework connection string.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="contextType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="connectionString" /> is <c>null</c> or whitespace.</exception>
public static string GetEntityFrameworkConnectionString(Type contextType, string connectionString)
{
Argument.IsNotNull("contextType", contextType);
Argument.IsNotNullOrWhitespace("connectionString", connectionString);
if (connectionString.Contains("res://"))
{
// already EF connection string
return connectionString;
}
var fullName = contextType.FullName;
if (fullName.EndsWith("Container"))
{
fullName = fullName.Substring(0, fullName.Length - "Container".Length);
}
var assemblyNameParts = contextType.Assembly.GetName().Name.Split(new[] { '.' });
foreach (var assemblyNamePart in assemblyNameParts)
{
string itemToReplace = string.Format("{0}.", assemblyNamePart);
if (fullName.StartsWith(itemToReplace))
{
fullName = fullName.Remove(0, itemToReplace.Length);
}
}
var connectionBuilder = new EntityConnectionStringBuilder();
connectionBuilder.Provider = "System.Data.SqlClient";
connectionBuilder.Metadata = string.Format("res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl", fullName);
connectionBuilder.ProviderConnectionString = connectionString;
return connectionBuilder.ToString();
}
/// <summary>
/// Creates the entity connection with wrappers.
/// </summary>
/// <param name="entityConnectionString">The original entity connection string. This may also be a single word, e.g., "MyEntities", in which case it is translated into "name=MyEntities" and looked up in the application configuration.</param>
/// <param name="wrapperProviders">List for wrapper providers.</param>
/// <returns>EntityConnection object which is based on a chain of providers.</returns>
public static EntityConnection CreateEntityConnectionWithWrappers(string entityConnectionString, params string[] wrapperProviders)
{
// If there is only a single word in the connection string, treat it as the value for Name.
if (!entityConnectionString.Contains('='))
entityConnectionString = "name=" + entityConnectionString;
EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder(entityConnectionString);
// if connection string is name=EntryName, look up entry in the config file and parse it
if (!String.IsNullOrEmpty(ecsb.Name))
{
var connStr = ConfigurationManager.ConnectionStrings[ecsb.Name];
if (connStr == null)
{
throw new ArgumentException("Specified named connection string '" + ecsb.Name + "' was not found in the configuration file.");
}
ecsb.ConnectionString = connStr.ConnectionString;
}
var workspace = metadataWorkspaceMemoizer.GetOrAdd(ecsb.ConnectionString, _ => CreateWrappedMetadataWorkspace(ecsb.Metadata, wrapperProviders));
var storeConnection = DbProviderFactories.GetFactory(ecsb.Provider).CreateConnection();
storeConnection.ConnectionString = ecsb.ProviderConnectionString;
var newEntityConnection = new EntityConnection(workspace, DbConnectionWrapper.WrapConnection(storeConnection, wrapperProviders));
return newEntityConnection;
}
public void EntityConnectionFactory_CreatePersistentEntityConnection()
{
var connString = this.GetDefaultConnectionString();
var csBuilder = new EntityConnectionStringBuilder(connString);
csBuilder.ProviderConnectionString = Guid.NewGuid().ToString();
EntityConnection connection = EntityConnectionFactory.CreatePersistent(csBuilder.ConnectionString);
}
public void EntityConnectionFactory_ImplicitMetadata()
{
var connString = this.GetDefaultConnectionString();
var csBuilder = new EntityConnectionStringBuilder(connString);
csBuilder.Metadata = "res://*/";
csBuilder.ProviderConnectionString = Guid.NewGuid().ToString();
EntityConnectionFactory.CreateTransient(csBuilder.ConnectionString);
}
public void MetadataWorkspaceHelperRewrite()
{
EntityConnectionStringBuilder nameResolver =
new EntityConnectionStringBuilder(NorthwindObjectContext.DefaultConnectionString);
string resolvedConnectionString =
ConfigurationManager.ConnectionStrings[nameResolver.Name].ConnectionString;
EntityConnectionStringBuilder connectionString =
new EntityConnectionStringBuilder(resolvedConnectionString);
MetadataWorkspace workspace =
MetadataWorkspaceHelper.Rewrite(
connectionString.Metadata,
EffortProviderConfiguration.ProviderInvariantName,
EffortProviderManifestTokens.Version1);
}
public IEnumerable <SELECT_cabecera_defectos_crea_list_MDL_Result> ObtenerListaDefectos(EntityConnectionStringBuilder connection, string fecha, string hora)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_cabecera_defectos_crea_list_MDL(fecha,
hora));
}
public IEnumerable <SELECT_decision_empleo_lote_crea_MDL_Result> ObtenerDecisionesEmpleo(EntityConnectionStringBuilder connection)
{
string fol = "";
var context = new samEntities(connection.ToString());
return(context.SELECT_decision_empleo_lote_crea_MDL(fol));
}
/// <summary>
/// Returns the full entity connection string if it formed as
/// "name=connectionStringName".
/// </summary>
/// <param name="entityConnectionString"> The entity connection string. </param>
/// <returns> The full entity connection string. </returns>
private static string GetFullEntityConnectionString(
string entityConnectionString)
{
EntityConnectionStringBuilder builder =
new EntityConnectionStringBuilder(entityConnectionString);
if (!string.IsNullOrWhiteSpace(builder.Name))
{
string connectionStringName = builder.Name;
ConnectionStringSettings setting =
ConfigurationManager.ConnectionStrings[connectionStringName];
if (setting == null)
{
throw new ArgumentException(
"Connectionstring was not found",
"entityConnectionString");
}
entityConnectionString = setting.ConnectionString;
}
return entityConnectionString;
}
public void IngresaClaseAviso(EntityConnectionStringBuilder connection, ClaseAviso cla)
{
var context = new samEntities(connection.ToString());
context.INSERT_clase_aviso_MDL(cla.QMART);
}
public void VaciarClaseAviso(EntityConnectionStringBuilder connection)
{
var context = new samEntities(connection.ToString());
context.TRUNCATE_clase_aviso_MDL();
}
public void VaciarResponsable(EntityConnectionStringBuilder connection)
{
var context = new samEntities(connection.ToString());
context.TRUNCATE_puesto_trabajo_responsable_MDL();
}
public void VaciarGrupoPlan(EntityConnectionStringBuilder connection)
{
var context = new samEntities(connection.ToString());
context.DELETE_grupo_planificacion_avisos_MDL();
}
private async Task <TestConnectionData> TestConnectionAsync(string connectionString, string name, DatabaseType databaseType = DatabaseType.Dynamic)
{
TestConnectionData data = new TestConnectionData
{
ConnectionString = connectionString,
Name = name
};
try
{
if (databaseType == DatabaseType.SqlDatabase || databaseType == DatabaseType.SqlServer)
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = connectionString;
await conn.OpenAsync();
data.Succeeded = true;
}
}
else if (databaseType == DatabaseType.MySql)
{
using (MySqlConnection conn = new MySqlConnection())
{
conn.ConnectionString = connectionString;
await conn.OpenAsync();
data.Succeeded = true;
}
}
else if (databaseType == DatabaseType.PostgreSql)
{
using (NpgsqlConnection conn = new NpgsqlConnection())
{
conn.ConnectionString = connectionString;
await conn.OpenAsync();
data.Succeeded = true;
}
}
else if (databaseType == DatabaseType.RedisCache)
{
using (var muxer = await ConnectionMultiplexer.ConnectAsync(connectionString))
{
data.Succeeded = true;
}
}
else if (databaseType == DatabaseType.Dynamic)
{
using (SqlConnection conn = new SqlConnection())
{
conn.ConnectionString = connectionString;
await conn.OpenAsync();
data.Succeeded = true;
}
}
else if (databaseType == DatabaseType.NotSupported)
{
throw new Exception("This type of connection string is not yet supported by this tool");
}
else if (databaseType == DatabaseType.Custom)
{
if (connectionString.StartsWith("metadata=res://", StringComparison.OrdinalIgnoreCase))
{
data.IsEntityFramework = true;
var ec = new EntityConnectionStringBuilder(connectionString);
using (var connection = CreateDbConnection(ec.Provider, ec.ProviderConnectionString))
{
if (connection != null)
{
await connection.OpenAsync();
data.Succeeded = true;
}
}
}
else if (connectionString.IndexOf("Driver=", StringComparison.OrdinalIgnoreCase) >= 0)
{
data.IsCustomDriver = true;
using (OdbcConnection conn = new OdbcConnection())
{
conn.ConnectionString = connectionString;
await conn.OpenAsync();
data.Succeeded = true;
}
}
else if (CloudStorageAccount.TryParse(connectionString, out CloudStorageAccount csa))
{
data.IsAzureStorage = true;
var cloudTableClient = csa.CreateCloudTableClient();
var tableNames = await cloudTableClient.ListTablesSegmentedAsync(null);
data.Succeeded = true;
}
else
{
throw new Exception("Failed to determine the kind of connection string");
}
}
}
catch (Exception exception)
{
data.ExceptionDetails = exception;
}
return(data);
}
public IEnumerable <SELECT_textos_decision_empleo_MDL_Result> ObtenerTextosDecisionEmpleo(EntityConnectionStringBuilder connection)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_textos_decision_empleo_MDL());
}
public IEnumerable <SELECT_posiciones_defectos_crea_Folio_MDL_Result> ObtenerPosicionesDefectosFolio(EntityConnectionStringBuilder connection, string folio_sam)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_posiciones_defectos_crea_Folio_MDL(folio_sam));
}
public void VaciarDocumentosInventario(EntityConnectionStringBuilder connection, string centro)
{
var context = new samEntities(connection.ToString());
context.Truncate_documentos_inventario_MDL(centro);
}
public IEnumerable <SELECT_textos_defectos_crea_MDL_Result> ObtenerTextosDefectos(EntityConnectionStringBuilder connection)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_textos_defectos_crea_MDL());
}
private static EntityConnection CreateInspectedFakeEntityConnection(string entityConnectionString, IResultSetComposer resultSetComposer, bool createFake, IDataLoader dataLoader)
{
EntityConnectionStringBuilder connectionString = new EntityConnectionStringBuilder(entityConnectionString);
if (!string.IsNullOrEmpty(connectionString.Name))
{
string resolvedConnectionString = ConfigurationManager.ConnectionStrings[connectionString.Name].ConnectionString;
connectionString = new EntityConnectionStringBuilder(resolvedConnectionString);
}
List<XElement> csdl = new List<XElement>();
List<XElement> ssdl = new List<XElement>();
List<XElement> msl = new List<XElement>();
MetadataWorkspaceHelper.ParseMetadata(connectionString.Metadata, csdl, ssdl, msl);
foreach (XElement ssdlFile in ssdl)
{
XAttribute providerAttribute = ssdlFile.Attribute("Provider");
XAttribute providerManifestTokenAttribute = ssdlFile.Attribute("ProviderManifestToken");
if (createFake)
{
EffortProviderConfiguration.VerifyProvider();
UniversalStorageSchemaModifier.Instance.Modify(ssdlFile, new EffortProviderInformation());
}
string oldProviderInvariantName = providerAttribute.Value;
string oldProviderManifestToken = providerManifestTokenAttribute.Value;
providerAttribute.Value = DataReaderInspectorProviderConfiguration.ProviderInvariantName;
providerManifestTokenAttribute.Value = string.Format("{0};{1}", oldProviderInvariantName, oldProviderManifestToken);
}
MetadataWorkspace convertedWorkspace = MetadataWorkspaceHelper.CreateMetadataWorkspace(csdl, ssdl, msl);
DbConnection storeConnection = null;
if (createFake)
{
storeConnection = Effort.DbConnectionFactory.CreateTransient(dataLoader);
}
else
{
storeConnection = ProviderHelper.CreateConnection(connectionString.Provider);
storeConnection.ConnectionString = connectionString.ProviderConnectionString;
}
DbConnectionWrapper inspectorConnection = new DataReaderInspectorConnection(resultSetComposer);
inspectorConnection.WrappedConnection = storeConnection;
#if !EFOLD
EntityConnection entityConnection =
new EntityConnection(convertedWorkspace, inspectorConnection, true);
#else
EntityConnection entityConnection =
new EntityConnection(convertedWorkspace, inspectorConnection);
FieldInfo owned =
typeof(EntityConnection)
.GetField(
"_userOwnsStoreConnection",
BindingFlags.Instance | BindingFlags.NonPublic);
owned.SetValue(entityConnection, false);
#endif
if (createFake)
{
using (ObjectContext objectContext = new ObjectContext(entityConnection))
{
if (!objectContext.DatabaseExists())
{
objectContext.CreateDatabase();
}
}
}
return entityConnection;
}
public IEnumerable <SELECT_defectos_datos_id_MDL_Result> ObtenerDatosIdDefectos(EntityConnectionStringBuilder connection, int id)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_defectos_datos_id_MDL(id));
}
public void Edmx_LoadRelatedEntities_Should_Populate_Multiple_Orders_With_Customer()
{
// Create DB usng CodeFirst context
string providerConnectionString;
using (var cf = TestsHelper.CreateNorthwindDbContext(CreateNorthwindDbOptions))
{
providerConnectionString = cf.Database.Connection.ConnectionString;
}
// Connect using ModelFirst context
var asm = System.Reflection.Assembly.GetExecutingAssembly();
var paths = from res in asm.GetManifestResourceNames()
//where res.Contains("Northwind")
where new string[] { ".csdl", ".ssdl", ".msl" }.Contains(System.IO.Path.GetExtension(res))
select string.Format("res://{0}/{1}", asm.GetName().Name, res);
var conn = new EntityConnectionStringBuilder();
conn.Metadata = string.Join("|", paths);
conn.Provider = "System.Data.SqlClient";
conn.ProviderConnectionString = providerConnectionString;
var context = new TrackableEntities.EF.Tests.Contexts.NorthwindDbContext(conn.ToString());
Database.SetInitializer<TrackableEntities.EF.Tests.Contexts.NorthwindDbContext>(null);
// Arrange
var orders = CreateTestOrders(context);
orders.ForEach(o => o.TrackingState = TrackingState.Added);
// Act
context.LoadRelatedEntities(orders);
// Assert
Assert.IsFalse(orders.Any(o => o.Customer == null));
Assert.IsFalse(orders.Any(o => o.Customer.CustomerId != o.CustomerId));
}
public IEnumerable <SELECT_defectos_valida_hora_MDL_Result> ObtenerValidacionHoraDefectos(EntityConnectionStringBuilder connection, int id, string hora)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_defectos_valida_hora_MDL(id,
hora));
}
/// <summary>
/// Returns a metadata workspace that is rewritten in order to be compatible the
/// Effort provider.
/// </summary>
/// <param name="entityConnectionString">
/// The entity connection string that references the original metadata.
/// </param>
/// <returns>
/// The rewritten metadata.
/// </returns>
private static MetadataWorkspace GetEffortCompatibleMetadataWorkspace(
ref string entityConnectionString)
{
EffortProviderConfiguration.VerifyProvider();
entityConnectionString = GetFullEntityConnectionString(entityConnectionString);
EntityConnectionStringBuilder connectionStringBuilder =
new EntityConnectionStringBuilder(entityConnectionString);
return MetadataWorkspaceStore.GetMetadataWorkspace(
connectionStringBuilder.Metadata,
metadata => MetadataWorkspaceHelper.Rewrite(
metadata,
EffortProviderConfiguration.ProviderInvariantName,
EffortProviderManifestTokens.Version1));
}
public IEnumerable <SELEC_fol_defectos_menos_MDL_Result> ObtenerFolioMenosDefectos(EntityConnectionStringBuilder connection, int id)
{
var context = new samEntities(connection.ToString());
return(context.SELEC_fol_defectos_menos_MDL(id));
}
public static MetadataWorkspace GetMetadataWorkspace(
string connectionStringName,
Assembly assembly)
{
var conn = ConfigurationManager.ConnectionStrings[connectionStringName];
var builder = new EntityConnectionStringBuilder(conn.ConnectionString);
var metadata = builder.Metadata.Split('|').Select(x => x.Trim());
return new MetadataWorkspace(metadata, new[] { assembly });
}
public IEnumerable <SELECT_lista_folios_defectos_MDL_Result> ObtenerTodoFolioDefectos(EntityConnectionStringBuilder connection, string folio_sam)
{
var context = new samEntities(connection.ToString());
return(context.SELECT_lista_folios_defectos_MDL(folio_sam));
}
public static string GetDB0EntityString(string configstring)
{
string[] DataConnectionInfo = configstring.Split(',');
SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder();
builder.DataSource = DataConnectionInfo[0];
builder.UserID = DataConnectionInfo[1];
builder.Password = DataConnectionInfo[2];
builder.InitialCatalog = DatabaseName;
builder.IntegratedSecurity = false;
builder.PersistSecurityInfo = false;
EntityConnectionStringBuilder entBuilder = new EntityConnectionStringBuilder();
entBuilder.Provider = "System.Data.SqlClient";
entBuilder.ProviderConnectionString = builder.ConnectionString;
entBuilder.Metadata = String.Format("res://{0}/{1}.csdl|res://{0}/{1}.ssdl|res://{0}/{1}.msl", "Proc.BusinessLogic", "DB0." + DatabaseName);
return entBuilder.ConnectionString;
}
/// <summary>
/// Ensure the database needed by EF and Hybrid service is created
/// </summary>
public static void EnsureDatabaseCreated()
{
const string databaseName = "AstoriaDefaultServiceDB";
const string resourceName = "Microsoft.Test.OData.Services.Astoria.PublicProvider.AstoriaDefaultServiceDB.bak";
Log.Trace(string.Format("Ensure database {0} exists", databaseName));
var entityConnBuilder = new EntityConnectionStringBuilder(ConnectionString);
var sqlConnBuilder = new SqlConnectionStringBuilder(entityConnBuilder.ProviderConnectionString)
{
InitialCatalog = "master"
};
using (var conn = new SqlConnection(sqlConnBuilder.ToString()))
{
conn.Open();
bool databaseExist;
using (var cmd = new SqlCommand("SELECT COUNT(*) FROM sys.databases WHERE name = @name", conn))
{
cmd.Parameters.AddWithValue("@name", databaseName);
databaseExist = (int)cmd.ExecuteScalar() > 0;
}
if (!databaseExist)
{
Log.Trace(string.Format("Database {0} does not exist", databaseName));
using (Stream resource = typeof(DatabaseHelper).Assembly
.GetManifestResourceStream(resourceName))
{
if (resource == null)
{
throw new ArgumentException("No such resource", resourceName);
}
const string temp = "Temp";
if (!Directory.Exists(temp))
{
Directory.CreateDirectory(temp);
}
DirectorySecurity sec = Directory.GetAccessControl(temp);
var everyone = new SecurityIdentifier(WellKnownSidType.WorldSid, null);
sec.AddAccessRule(
new FileSystemAccessRule(everyone,
FileSystemRights.Modify |
FileSystemRights.Synchronize,
InheritanceFlags.ContainerInherit |
InheritanceFlags.ObjectInherit, PropagationFlags.None,
AccessControlType.Allow));
Directory.SetAccessControl(temp, sec);
string file = Path.GetFullPath(Path.Combine(temp, databaseName + ".bak"));
string mdf = Path.GetFullPath(Path.Combine(temp, databaseName + ".mdf"));
string ldf = Path.GetFullPath(Path.Combine(temp, databaseName + ".ldf"));
Log.Trace(string.Format("Output database backup to {0}.", file));
using (Stream output = File.OpenWrite(file))
{
resource.CopyTo(output);
}
string restorecmd = string.Format(
"RESTORE DATABASE AstoriaDefaultServiceDB FROM DISK = '{0}' WITH MOVE 'AstoriaDefaultServiceDB' TO '{1}', MOVE 'AstoriaDefaultServiceDB_log' TO '{2}', REPLACE", file, mdf, ldf);
Log.Trace(restorecmd);
using (var cmd = new SqlCommand(restorecmd, conn))
{
cmd.ExecuteNonQuery();
}
}
}
}
}
