public string GetSql()
{
var rawSqlQuery = OrmConfiguration.GetSqlBuilder <TestModel>().Format(
$@"SELECT {nameof(Id):C},{nameof(Name):C} FROM {nameof(TestModel):T}");
return(rawSqlQuery);
}
private static void SetupRole()
{
OrmConfiguration.GetDefaultEntityMapping <Role>()
.SetTableName("Role")
.SetProperty(role => role.Id,
prop => prop.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.Identity));
}
public async Task <QuyenTacVu> UpdatePartial(QuyenTacVu quyen, params string[] field)
{
return(await WithConnection(async c =>
{
QuyenTacVu obj = await c.GetAsync(quyen);
if (obj == null)
{
await c.InsertAsync(quyen);
if (quyen.ChucNangId == 0)
{
throw new Exception("Insert Fail");
}
return quyen;
}
var list = field.ToList();
var partialUpdateMapping = OrmConfiguration
.GetDefaultEntityMapping <QuyenTacVu>()
.Clone() // clone it if you don't want to modify the default
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true,
list.ToArray());
var result = await c.UpdateAsync(quyen, statement => statement.WithEntityMappingOverride(partialUpdateMapping));
if (result != true)
{
throw new Exception("Update Fail");
}
return quyen;
}));
}
public static DBProviderBase <TEntity> GetDbProvider(OrmConfiguration ormConfiguration)
{
try
{
Lazy <ConfigurationManagementManager> configReader = new Lazy <ConfigurationManagementManager>(() => new ConfigurationManagementManager());
Type TE = typeof(TEntity);
string _providerName = configReader.Value.Get <string>("gooDBProvider");
string providerName = string.Concat("Goo.OrmCore.", _providerName, "`1[[", TE.AssemblyQualifiedName, "]]");
Type TP = Type.GetType(providerName, true, true);
var providerInstance = TP.GetMethod("get_getInstance").Invoke(null, null);
providerInstance.GetType().GetMethod("SetOrmConfiguration").Invoke(providerInstance, new object[] { ormConfiguration });
return(OrmHelper.getInstance.ConvertTo <DBProviderBase <TEntity> >(providerInstance));
}
catch (Exception ex)
{
throw new Exception("This provider type is not supported for Goo. Detail:" + ex.ToString());
}
}
public async Task <KhoHangHoa> UpdatePartial(KhoHangHoa khachhang, params string[] field)
{
var a = await WithConnection(async c =>
{
KhoHangHoa obj = await c.GetAsync(khachhang);
if (obj == null)
{
throw new Exception(string.Format("Update id {0} not exist", khachhang.HangHoaId.ToString()));
}
var list = field.ToList();
var partialUpdateMapping = OrmConfiguration
.GetDefaultEntityMapping <KhoHangHoa>()
.Clone()
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true,
list.ToArray());
var result = await c.UpdateAsync(khachhang, statement => statement.WithEntityMappingOverride(partialUpdateMapping));
if (result != true)
{
throw new Exception("Update Fail");
}
return(khachhang);
});
return(a);
}
public void WhenIPartiallyUpdateAllTheInsertedEmployeeEntities()
{
// prepare a new mapping
var defaultMapping = OrmConfiguration.GetDefaultEntityMapping <Employee>();
Assert.IsTrue(defaultMapping.IsFrozen);
var lastNamePropMapping = defaultMapping.GetProperty(employee => employee.LastName);
try
{
// updates are not possible when the mapping is frozen
defaultMapping.SetProperty(employee => employee.LastName, propMapping => propMapping.ExcludeFromUpdates());
Assert.Fail();
}
catch (InvalidOperationException)
{
}
var customMapping = defaultMapping.Clone().UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(Employee.LastName), nameof(Employee.FullName));
for (var entityIndex = 0; entityIndex < _testContext.LocalEntities.Count; entityIndex++)
{
var insertedEntity = _testContext.LocalEntities[entityIndex] as Employee;
if (insertedEntity == null)
{
continue;
}
var partialUpdatedEntity = new Employee()
{
UserId = insertedEntity.UserId,
EmployeeId = insertedEntity.EmployeeId,
BirthDate = new DateTime(2020, 03, 01),
WorkstationId = 10 + insertedEntity.WorkstationId,
FirstName = "Updated " + insertedEntity.FirstName,
// all of the above will be ignored with the exception of the next ones
LastName = "Updated " + insertedEntity.LastName
};
_testContext.DatabaseConnection.Update(partialUpdatedEntity, statement => statement.WithEntityMappingOverride(customMapping));
_testContext.LocalEntities[entityIndex] = new Employee()
{
UserId = insertedEntity.UserId,
KeyPass = insertedEntity.KeyPass,
EmployeeId = insertedEntity.EmployeeId,
BirthDate = insertedEntity.BirthDate,
WorkstationId = insertedEntity.WorkstationId,
FirstName = insertedEntity.FirstName,
// all of the above were ignored with the exception of the next ones
LastName = partialUpdatedEntity.LastName,
FullName = partialUpdatedEntity.FullName
};
}
}
internal void Save(IDbConnection db)
{
if (!_licensesToRemove.IsEmpty)
{
var idsToRemove = new StringBuilder();
var firstRun = true;
License licenseToRemove;
while (_licensesToRemove.TryPop(out licenseToRemove))
{
if (firstRun)
{
firstRun = false;
}
else
{
idsToRemove.Append(',');
}
idsToRemove.Append(licenseToRemove.Id);
}
db.BulkDelete <PlayerLicenseDto>(statement => statement
.Where($"{nameof(PlayerLicenseDto.Id):C} IN ({idsToRemove})"));
}
foreach (var license in this)
{
if (!license.ExistsInDatabase)
{
db.Insert(new PlayerLicenseDto
{
Id = license.Id,
PlayerId = (int)_player.Account.Id,
License = (byte)license.ItemLicense,
FirstCompletedDate = license.FirstCompletedDate.ToUnixTimeSeconds(),
CompletedCount = license.TimesCompleted
});
license.ExistsInDatabase = true;
}
else
{
if (!license.NeedsToSave)
{
continue;
}
var mapping = OrmConfiguration
.GetDefaultEntityMapping <PlayerLicenseDto>()
.Clone()
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true,
nameof(PlayerLicenseDto.CompletedCount));
db.Update(new PlayerLicenseDto
{
CompletedCount = license.TimesCompleted
}, statement => statement.WithEntityMappingOverride(mapping));
license.NeedsToSave = false;
}
}
}
private static void SetupUser()
{
OrmConfiguration.GetDefaultEntityMapping <User>()
.SetTableName("User")
.SetProperty(user => user.Id,
prop => prop.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.Identity))
.SetProperty(user => user.RoleId,
prop => prop.SetChildParentRelationship <Role>("Role"));
}
static XtcsModel()
{
OrmConfiguration.GetDefaultEntityMapping <XtcsModel>()
.SetProperty(entity => entity.Id,
prop =>
{
prop.SetDatabaseColumnName("Xtcsdm00");
});
}
private void PrepareEnvironment <TEntity>(SqlDialect dialect)
{
OrmConfiguration.DefaultDialect = dialect;
// in real library usage, people will use the ISqlBuilder, but for our tests we're gonna need more than that
_currentSqlBuilder = OrmConfiguration.GetSqlBuilder <TEntity>() as IStatementSqlBuilder;
_currentDialect = dialect;
_selectColumnNames = _currentSqlBuilder.SelectProperties.Select(propInfo => propInfo.DatabaseColumnName).ToArray();
}
static BaseDapperFastCrud()
{
InfoMapping.Add(Common.SettingItem.DBType.MSSQL,
OrmConfiguration.GetDefaultEntityMapping <T>()
.Clone().SetDialect(SqlDialect.MsSql));
InfoMapping.Add(Common.SettingItem.DBType.POSTGRESQL,
OrmConfiguration.GetDefaultEntityMapping <T>()
.Clone().SetDialect(SqlDialect.PostgreSql));
}
private void SetupOrmConfiguration(SqlDialect dialect)
{
OrmConfiguration.DefaultDialect = dialect;
OrmConfiguration.RegisterEntity <Building>()
.SetTableName("Buildings")
.SetProperty(building => building.BuildingId, propMapping => propMapping.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.Identity).SetDatabaseColumnName("Id"))
.SetProperty(building => building.Name, propMapping => propMapping.SetDatabaseColumnName("BuildingName"));
}
public static void SetDialogueIfNeeded_AddsMappedIsFroozenToDictionary()
{
var target = new SqlDialectHelper();
target.SetDialogueIfNeeded <Brave>(SqlDialect.SqLite);
var result = target.GetEntityState <Brave>();
Assert.That(result.HasValue, Is.True);
Assert.That(OrmConfiguration.GetDefaultEntityMapping <Brave>().Dialect, Is.EqualTo(SqlDialect.SqLite));
}
static DepartmentModel()
{
OrmConfiguration.GetDefaultEntityMapping <DepartmentModel>()
.SetProperty(entity => entity.Id,
prop =>
{
prop.SetDatabaseColumnName("Did");
prop.SetDatabaseGenerated(DatabaseGeneratedOption.Identity);
});
}
static Arz0Model()
{
OrmConfiguration.GetDefaultEntityMapping <Arz0Model>()
.SetProperty(entity => entity.Id,
prop =>
{
prop.SetDatabaseColumnName("Arz0xh00");
prop.SetDatabaseGenerated(DatabaseGeneratedOption.Identity);
});
}
static ExtendTypeItemModel()
{
OrmConfiguration.GetDefaultEntityMapping <ExtendTypeItemModel>()
.SetProperty(entity => entity.Id,
prop =>
{
prop.SetDatabaseColumnName("Id");
prop.SetDatabaseGenerated(DatabaseGeneratedOption.Identity);
});
}
public void ThenIShouldGetAValidJoinQueryStatementForWorkstation()
{
var buildingSqlBuilder = OrmConfiguration.GetSqlBuilder <Building>();
var expectedQuery =
$@" SELECT {_currentSqlBuilder.GetTableName()}.{_currentSqlBuilder.GetColumnName(nameof(Workstation.WorkstationId))}, {buildingSqlBuilder.GetTableName()}.{buildingSqlBuilder.GetColumnName(nameof(Building.BuildingId))}
FROM {_currentSqlBuilder.GetTableName()}, {buildingSqlBuilder.GetTableName()}
WHERE {_currentSqlBuilder.GetTableName()}.{_currentSqlBuilder.GetColumnName(nameof(Workstation.BuildingId))} = {buildingSqlBuilder.GetTableName()}.{buildingSqlBuilder.GetColumnName(nameof(Building.BuildingId))}";
Assert.AreEqual(expectedQuery, _buildingRawJoinQueryStatement);
}
public static void SetDialogueIfNeeded_SetsIsFroozenInDictionary()
{
var repo = new BraveRepository(Factory);
repo.GetKey <ITestSession>(1);
var target = new SqlDialectHelper();
var result = target.GetEntityState <Brave>();
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.True);
Assert.That(OrmConfiguration.GetDefaultEntityMapping <Brave>().Dialect, Is.EqualTo(SqlDialect.SqLite));
}
public void WhenIQueryForAMaximumOfWorkstationEntitiesInReverseOrderOfWorkstationIdSkippingRecords(int?max, int?skip)
{
var sqlBuilder = OrmConfiguration.GetSqlBuilder <Workstation>();
_testContext.QueriedEntities.AddRange(
_testContext.DatabaseConnection.Find <Workstation>(
statementOptions =>
statementOptions.Where($"{nameof(Workstation.WorkstationId):C} IS NOT NULL")
.OrderBy($"{nameof(Workstation.InventoryIndex):C} DESC")
.Skip(skip)
.Top(max)));
}
public void DisableAllDatesByEventId(long eventId)
{
var partialUpdateMapping = OrmConfiguration
.GetDefaultEntityMapping <PlaceHolidayDate>()
.Clone() // clone it if you don't want to modify the default
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(PlaceHolidayDate.IsEnabled));
GetCurrentConnection().BulkUpdate(
new PlaceHolidayDate
{
IsEnabled = false, // You can add as many as fields you want to update
}, statement => statement.WithEntityMappingOverride(partialUpdateMapping).Where($"{nameof(PlaceHolidayDate.EventId):C}=@EventId").WithParameters(new { EventId = eventId }).AttachToTransaction(GetCurrentTransaction()));
}
public static void Table_Will_SetDialect()
{
var connection = CreateSession(null);
var sql = SqlInstance.Instance;
connection.Query($"SELECT * FROM {sql.Table<Brave>(connection.SqlDialect)}");
var target = new SqlDialectHelper();
var result = target.GetEntityState <Brave>();
Assert.That(result.HasValue, Is.True);
Assert.That(result.Value, Is.True);
Assert.That((int)OrmConfiguration.GetDefaultEntityMapping <Brave>().Dialect, Is.EqualTo((int)connection.SqlDialect));
}
public void DisableAllVariants(string productId)
{
var partialUpdateMapping = OrmConfiguration
.GetDefaultEntityMapping <TiqetVariantDetail>()
.Clone() // clone it if you don't want to modify the default
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(TiqetVariantDetail.IsEnabled));
GetCurrentConnection().BulkUpdate(
new TiqetVariantDetail
{
IsEnabled = false,
}, statement => statement.WithEntityMappingOverride(partialUpdateMapping).Where($"{nameof(TiqetVariantDetail.ProductId):C}=@ProductId").WithParameters(new { ProductId = productId }).AttachToTransaction(GetCurrentTransaction()));
}
public async Task CreateNickHandler(GameServer server, GameSession session, CCreateNickReqMessage message)
{
if (session.Player == null || !string.IsNullOrWhiteSpace(session.Player.Account.Nickname))
{
session.Dispose();
return;
}
Logger.Info()
.Account(session)
.Message($"Creating nickname {message.Nickname}")
.Write();
if (!await IsNickAvailableAsync(message.Nickname).ConfigureAwait(false))
{
Logger.Error()
.Account(session)
.Message($"Nickname not available: {message.Nickname}")
.Write();
await session.SendAsync(new SCheckNickAckMessage(false))
.ConfigureAwait(false);
return;
}
session.Player.Account.Nickname = message.Nickname;
using (var db = AuthDatabase.Open())
{
var mapping = OrmConfiguration
.GetDefaultEntityMapping <AccountDto>()
.Clone()
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(AccountDto.Nickname));
await db.UpdateAsync(new AccountDto { Id = (int)session.Player.Account.Id, Nickname = message.Nickname },
statement => statement.WithEntityMappingOverride(mapping))
.ConfigureAwait(false);
}
//session.Send(new SCreateNickAckMessage { Nickname = msg.Nickname });
await session.SendAsync(new SServerResultInfoAckMessage(ServerResult.CreateNicknameSuccess))
.ConfigureAwait(false);
Logger.Info()
.Account(session)
.Message($"Created nickname {message.Nickname}")
.Write();
await LoginAsync(server, session)
.ConfigureAwait(false);
}
public WalletMap()
{
OrmConfiguration.RegisterEntity <Wallet>()
.SetTableName("Wallets")
.SetProperty(c => c.Id,
prop => prop.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.None))
.SetProperty(c => c.ClientId, prop => prop.SetDatabaseColumnName("ClientId").SetChildParentRelationship <Client>("Client"))
.SetProperty(c => c.CurrencyTypeId, prop => prop.SetDatabaseColumnName("CurrencyTypeId").SetChildParentRelationship <CurrencyType>("CurrencyType"))
.SetProperty(c => c.Status, prop => prop.SetDatabaseColumnName("Status"))
.SetProperty(c => c.Created, prop => prop.SetDatabaseColumnName("Created"))
.SetProperty(c => c.Updated, prop => prop.SetDatabaseColumnName("Updated"))
.SetProperty(c => c.Deleted, prop => prop.SetDatabaseColumnName("Deleted"))
;
}
public void DisableAll()
{
var partialUpdateMapping = OrmConfiguration
.GetDefaultEntityMapping <TiqetEventDetailMapping>()
.Clone() // clone it if you don't want to modify the default
.UpdatePropertiesExcluding(prop => prop.IsExcludedFromUpdates = true, nameof(TiqetEventDetailMapping.IsEnabled));
GetCurrentConnection().BulkUpdate(
new TiqetEventDetailMapping
{
IsEnabled = false,
},
statement => statement.WithEntityMappingOverride(partialUpdateMapping)
.AttachToTransaction(GetCurrentTransaction()));
}
public ClientMap()
{
OrmConfiguration.RegisterEntity <Client>()
.SetTableName("Clients")
.SetProperty(c => c.Id,
prop => prop.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.None))
.SetProperty(c => c.FirstName, prop => prop.SetDatabaseColumnName("FirstName"))
.SetProperty(c => c.LastName, prop => prop.SetDatabaseColumnName("LastName"))
.SetProperty(c => c.Email, prop => prop.SetDatabaseColumnName("Email"))
.SetProperty(c => c.Status, prop => prop.SetDatabaseColumnName("Status"))
.SetProperty(c => c.Created, prop => prop.SetDatabaseColumnName("Created"))
.SetProperty(c => c.Updated, prop => prop.SetDatabaseColumnName("Updated"))
.SetProperty(c => c.Deleted, prop => prop.SetDatabaseColumnName("Deleted"))
;
}
public CurrencyTypeMap()
{
OrmConfiguration.RegisterEntity <CurrencyType>()
.SetTableName("CurrencyTypes")
.SetProperty(c => c.Id,
prop => prop.SetPrimaryKey().SetDatabaseGenerated(DatabaseGeneratedOption.None))
.SetProperty(c => c.Name, prop => prop.SetDatabaseColumnName("Name"))
.SetProperty(c => c.Initials, prop => prop.SetDatabaseColumnName("Initials"))
.SetProperty(c => c.Current, prop => prop.SetDatabaseColumnName("Current"))
.SetProperty(c => c.CultureInfoName, prop => prop.SetDatabaseColumnName("CultureInfoName"))
.SetProperty(c => c.Created, prop => prop.SetDatabaseColumnName("Created"))
.SetProperty(c => c.Updated, prop => prop.SetDatabaseColumnName("Updated"))
.SetProperty(c => c.Deleted, prop => prop.SetDatabaseColumnName("Deleted"))
;
}
static Repository()
{
OrmConfiguration
.RegisterEntity <ProductName>()
.SetSchemaName("Production")
.SetTableName("Product")
.SetProperty(x => x.ProductId)
.SetProperty(x => x.Name);
OrmConfiguration
.RegisterEntity <SalesLineTotal>()
.SetSchemaName("Sales")
.SetTableName("SalesOrderDetail")
.SetProperty(x => x.ProductId)
.SetProperty(x => x.LineTotal);
}
public static void Query_Wont_MakeFrozen()
{
var connection = new TestSessionMemory(A.Fake <IDbFactory>());
new MigrateDb(connection);
var target = new SqlDialectHelper();
target.Reset();
OrmConfiguration.RegisterEntity <Brave>();
connection.Query("SELECT * FROM Braves");
var result = target.GetEntityState <Brave>();
Assert.That(OrmConfiguration.GetDefaultEntityMapping <Brave>().IsFrozen, Is.False);
Assert.That(result.HasValue, Is.False);
}
static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddSingleton <IBaseRepostory <Bank>, BankRepository>()
.AddScoped <IDbConnection>(_ => new MySqlConnection("Server=172.17.0.1;DataBase=testedb;Uid=root;Pwd=example"))
.AddScoped(_ => OrmConfiguration
.GetDefaultEntityMapping <Bank>()
.SetDialect(SqlDialect.MySql)
.SetTableName("bank")
)
.AddSingleton <Service>()
.BuildServiceProvider();
serviceProvider.GetService <Service>().Run();
}
