public void Register(IRepository repository)
{
if (repositories.ContainsKey(repository.GetType().Name))
{
return;
}
repositories.Add(repository.GetType().Name, repository);
}
public void ReleasesSemaphoreAfterGetIsComplete()
{
var property = _cacheRepository.GetType().GetField("SemaphoreSlim", BindingFlags.Static | BindingFlags.NonPublic);
var semaphore = (SemaphoreSlim)property.GetValue(_cacheRepository);
Assert.AreEqual(1, semaphore.CurrentCount);
}
private void ShouldSaveUpdateAndDeleteEntitySuccessfully <TEntity>(IUnitOfWork unitOfWork,
IRepository <TEntity> repository,
TEntity randomEntity) where TEntity : IEntity
{
string repositoryMessage = string.Format("Failed in {0}.", repository.GetType().Name);
// Save new entity.
repository.Save(randomEntity);
unitOfWork.Session.Flush();
TEntity entityFromDatabase = repository.FirstOrDefault(randomEntity.Id);
Assert.IsNotNull(entityFromDatabase, repositoryMessage);
Assert.AreEqual(randomEntity, entityFromDatabase, repositoryMessage);
// Update entity.
randomEntity.CreatedOn = Singleton.TestDataProvider.ProvideRandomDateTime();
repository.Save(randomEntity);
unitOfWork.Session.Flush();
entityFromDatabase = repository.FirstOrDefault(randomEntity.Id);
Assert.IsNotNull(entityFromDatabase, repositoryMessage);
Assert.AreEqual(randomEntity, entityFromDatabase, repositoryMessage);
// Delete entity.
repository.Delete(randomEntity.Id);
unitOfWork.Session.Flush();
entityFromDatabase = repository.FirstOrDefault(randomEntity.Id);
Assert.IsNull(entityFromDatabase, repositoryMessage);
}
public void ReleasesLockAfterGetIsComplete()
{
var property = _cacheRepository.GetType().GetField("Locks", BindingFlags.Static | BindingFlags.NonPublic);
var locks = (ConcurrentDictionary <string, SemaphoreSlim>)property.GetValue(_cacheRepository);
Assert.AreEqual(1, locks.FirstOrDefault().Value.CurrentCount);
}
/// <summary>
/// Returns the actions available in repository.
/// </summary>
public IEnumerable <IDynamicApiAction> GetRepositoryActions(IRepositoryManager repositoryManager, IRepository repository)
{
var repositoryType = repository.GetType();
var interfaceType = repository.ImplementedInterface;
const BindingFlags flags = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
var interfaceMethods = new List <MethodInfo>(interfaceType.GetMethods(flags)
.Where(e => Attribute.IsDefined(e, typeof(ApiActionAttribute))));
foreach (Type interf in interfaceType.GetInterfaces())
{
foreach (MethodInfo method in interf.GetMethods(flags)
.Where(e => Attribute.IsDefined(e, typeof(ApiActionAttribute))))
{
if (!interfaceMethods.Contains(method))
{
interfaceMethods.Add(method);
}
}
}
foreach (var interfaceMethodInfo in interfaceMethods)
{
var methodInfo = repositoryType.GetMethod(interfaceMethodInfo.Name);
yield return(CreateRepositoryAction(repositoryManager, repository, methodInfo, interfaceMethodInfo));
}
}
public static async Task HardDeleteAsync <TEntity>(
this IRepository <TEntity> repository,
Expression <Func <TEntity, bool> > predicate,
bool autoSave = false,
CancellationToken cancellationToken = default
)
where TEntity : class, IEntity, ISoftDelete
{
if (!(ProxyHelper.UnProxy(repository) is IUnitOfWorkManagerAccessor unitOfWorkManagerAccessor))
{
throw new AbpException($"The given repository (of type {repository.GetType().AssemblyQualifiedName}) should implement the {typeof(IUnitOfWorkManagerAccessor).AssemblyQualifiedName} interface in order to invoke the {nameof(HardDeleteAsync)} method!");
}
var uowManager = unitOfWorkManagerAccessor.UnitOfWorkManager;
if (uowManager == null)
{
throw new AbpException($"{nameof(unitOfWorkManagerAccessor.UnitOfWorkManager)} property of the given {nameof(repository)} object is null!");
}
if (uowManager.Current == null)
{
using (var uow = uowManager.Begin())
{
await HardDeleteWithUnitOfWorkAsync(repository, predicate, autoSave, cancellationToken, uowManager.Current);
await uow.CompleteAsync(cancellationToken);
}
}
else
{
await HardDeleteWithUnitOfWorkAsync(repository, predicate, autoSave, cancellationToken, uowManager.Current);
}
}
/// <summary>
/// 得到仓储定义的数据映射器的类型
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
internal static Type GetDataMapperType(IRepository repository)
{
var attribute = AttributeUtil.GetAttribute <DataMapperAttribute>(repository.GetType());
if (attribute == null)
{
return(null);
}
return(attribute.DataMapperType);
}
public NotificationsService(Routes routes, IRepository repository)
{
Check.IsNotNull(routes, "routes");
Check.IsNotNull(repository, "repository");
this.routes = routes;
this.repository = repository;
Log.InfoFormat("Service initialized. Repository: [{0}].", repository.GetType());
}
private static DataStructureReadParameters CreateDataStructureReadParameters(IRepository repository, Type type)
{
var readParameterTypesProperty = repository.GetType().GetField("ReadParameterTypes", BindingFlags.Public | BindingFlags.Static);
var specificFilterTypes = readParameterTypesProperty == null?
Array.Empty <KeyValuePair <string, Type> >() :
(KeyValuePair <string, Type>[])readParameterTypesProperty.GetValue(null);
return(new DataStructureReadParameters(new Dictionary <string, KeyValuePair <string, Type>[]> {
{ type.FullName, specificFilterTypes }
}));
}
private void ShouldGetAnyEntitySuccessfully <TEntity>(IRepository <TEntity> repository) where TEntity : IEntity
{
string repositoryMessage = string.Format("Failed in {0}.", repository.GetType().Name);
TEntity entity = repository.AsQueryable().FirstOrDefault();
Assert.IsNotNull(entity, repositoryMessage + " Table is empty.");
TEntity entityViaGet = repository.FirstOrDefault(entity.Id);
Assert.IsNotNull(entityViaGet);
Assert.AreEqual(entity, entityViaGet);
}
private void ShouldLoadTop10EntitiesWithAllMethodSuccessfully <TEntity>(IRepository <TEntity> repository)
where TEntity : IEntity
{
string repositoryMessage = string.Format("Failed in {0}.", repository.GetType().Name);
var list = repository.AsQueryable().Take(10).ToList();
Assert.IsNotNull(list, repositoryMessage);
Assert.Greater(list.Count(), 0, repositoryMessage);
Assert.IsFalse(list.Any(f => f.DeletedOn != null), repositoryMessage);
}
public void Can_Resolve_Types_Without_Default_Ctor()
{
Container ioc = new Container();
ioc.For <ILogger>().Use <SqlServerLogger>();
ioc.For <IRepository <Employee> >().Use <SqlRepository <Employee> >();
IRepository <Employee> repository = ioc.Resolve <IRepository <Employee> >();
Assert.AreEqual(typeof(SqlRepository <Employee>), repository.GetType());
}
public Attachment(DObject obj, IRepository repository)
{
Id = obj.Id;
var type = repository.GetType(obj.TypeId);
Title = obj.GetTitle(type);
Type = type;
if (Type.IsProjectFile())
{
FileExtension = Path.GetExtension(Title);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="componentIdentifier">Component's identifier</param>
/// <param name="componentName">Component's name</param>
/// <param name="repository">The repository responsible to count</param>
/// <param name="predicate">The predicate</param>
public AbstractCounter(
object componentIdentifier,
string componentName,
IRepository <T, K> repository,
Expression <Func <T, bool> > predicate = null)
: base(componentIdentifier, componentName)
{
repository.NotNull(nameof(repository));
repository.GetType().Is <BaseRepository <T, K, C> >();
_repository = repository;
_predicate = predicate;
}
private static void RemoveExistingRepository(IRepository repository)
{
var repositoryInterfaces = repository.GetType().GetInterfaces().Where(i => i.Assembly == Assembly
.GetAssembly(typeof(RepositoryContainer)));
var existingRepository = _repositories.SingleOrDefault(r => !r.GetType().GetInterfaces().Where(i => i.Assembly == Assembly
.GetAssembly(typeof(RepositoryContainer))).Except(repositoryInterfaces).Any());
if (existingRepository != null)
{
_repositories.Remove(existingRepository);
}
}
public static T ByNid <T>(this IRepository <T> repo, int nid)
where T : ID7Node
{
var ret = repo.All.FirstOrDefault(x => x.nid == nid);
if (ret == null)
{
repo.Warn_n($"No nid matching [{nid}].",
$"‹{repo.GetType().Name}› : repo for ‹{typeof(T).Name}›.");
}
return(ret);
}
private Type GetEditorType(IRepository repository)
{
var entryType = repository.GetType().GetInterfaces().FirstOrDefault(item => item.IsGenericType && item.GetInterfaces().Contains(typeof(IRepository)));
foreach (var item in creators)
{
if (entryType.IsSubclassOf(item.Key) || entryType.Equals(item.Key))
{
return(item.Value);
}
}
throw new InvalidOperationException($"{entryType}' type not registered.");
}
private void ShouldCheckEntityForExistenceSuccessfully <TEntity>(IRepository <TEntity> repository)
where TEntity : IEntity
{
string repositoryMessage = string.Format("Failed in {0}.", repository.GetType().Name);
TEntity entity = repository.AsQueryable().FirstOrDefault();
Assert.IsNotNull(entity, repositoryMessage + " Table is empty.");
bool entityExist = repository.Any(f => f.Id == entity.Id);
Assert.IsTrue(entityExist, repositoryMessage);
bool entityNotExist = repository.Any(f => f.Id == -1);
Assert.IsFalse(entityNotExist, repositoryMessage);
}
/// <summary>
/// 强制转换指定仓库的数据提供程序为关系数据库的数据提供程。
/// 如果该仓库的 <see cref="IRepository.DataProvider"/> 不是此类型的子类，则会抛出异常。
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public static RdbDataProvider Get(IRepository repository)
{
var dp = repository.DataProvider as RdbDataProvider;
if (dp == null)
{
throw new InvalidProgramException(string.Format(
"{0} 仓库类型使用的数据提供程序类型是 {1}，该类型不能转换为关系数据库的数据提供程序。",
repository.GetType(),
repository.DataProvider.GetType()
));
}
return(dp);
}
private void SendBufferCallback(object state)
{
try
{
repository.Add((IEnumerable <logEvent>)state, BufferSize);
}
catch (Exception ex)
{
HandleError($"Failed to addd logEvents to {repository.GetType().Name} in SendBufferCallback", ex);
}
finally
{
EndAsyncSend();
}
}
public UnitOfWork(DbContext dbContext,
IRepository <User> userRep,
IRepository <Document> documentRep,
IRepository <Order> orderRep,
IRepository <Adress> adressRep,
IRepository <EmailConfirmationLink> emailRep
)
{
_db = dbContext;
_repositories = new Dictionary <Type, object>();
_repositories.Add(userRep.GetType().GenericTypeArguments[0], userRep);
_repositories.Add(documentRep.GetType().GenericTypeArguments[0], documentRep);
_repositories.Add(orderRep.GetType().GenericTypeArguments[0], orderRep);
_repositories.Add(adressRep.GetType().GenericTypeArguments[0], adressRep);
_repositories.Add(emailRep.GetType().GenericTypeArguments[0], emailRep);
}
public BitstampTrader(TimeSpan interval)
{
// Ninject
var kernel = new StandardKernel();
kernel.Load(Assembly.GetExecutingAssembly());
_minMaxLogRepository = kernel.Get <IRepository <MinMaxLog> >();
_orderRepository = kernel.Get <IRepository <Order> >();
_currencyPairRepository = kernel.Get <IRepository <CurrencyPair> >();
_exchange = kernel.Get <IExchange>();
if (_currencyPairRepository.GetType() == typeof(MockRepository <CurrencyPair>))
{
GenerateMockData();
}
Interval = interval;
}
public void EnsurePopulated()
{
if (typeof(Repository).IsAssignableFrom(repository.GetType()))
{
repository.AddGenres(Genres);
repository.AddOccasions(Occasions);
repository.AddMusicians(Musicians);
logger.LogInformation("Repository populated");
}
else
{
if (context.Database.GetPendingMigrations().Any())
{
context.Database.Migrate();
}
if (context.Musicians.Count() == 0 &&
context.Genres.Count() == 0 &&
context.Occasions.Count() == 0)
{
logger.LogDebug("Preparing to seed database");
context.Genres !.AddRange(Genres);
context.SaveChanges();
logger.LogDebug("Genres added");
context.Occasions !.AddRange(Occasions);
context.SaveChanges();
logger.LogDebug("Occasions added");
context.Musicians !.AddRange(Musicians);
context.SaveChanges();
logger.LogDebug("Musicians added");
logger.LogInformation("Database seeded");
}
else
{
logger.LogInformation("Database not seeded");
}
}
}
public static void UpdateRecordHash <T>(T entity, IRepository <T> repository)
where T : class, IEntity
{
if (entity == null || repository == null)
{
return;
}
var task = new Task(() =>
{
var tableInfo = TableInfo.GetTableInfo <T>();
if (entity != null && repository != null && tableInfo.IsIModifyRecord)
{
if (tableInfo.PKList == null || tableInfo.PKList.Count == 0)
{
//没有主键则不进行更新，以免出错
//这里进行记录日志预警
return;
}
var dataDict = EntityUtility.GetEntityDict <T>(entity);
if (dataDict == null || dataDict.Count == 0)
{
return;
}
string where = "1=1";
foreach (var pk in tableInfo.PKList)
{
if (dataDict.ContainsKey(pk) == false)
{
return;
}
where += string.Format(" AND {0}='{1}'", pk, dataDict[pk]);
}
string hash = EntityUtility.GetEntityHash <T>(entity);
string sql = string.Format("UPDATE {0} SET RecordHash='{1}' WHERE {2}", tableInfo.TableName, hash, where);
var repoType = repository.GetType();
var newRepo = Assembly.GetAssembly(repoType).CreateInstance(repoType.FullName, true, BindingFlags.Public | BindingFlags.Instance, null, new object[] { repository.ConnectionStr }, CultureInfo.CurrentCulture, null) as IRepository <T>;
newRepo.ExecuteNonQueryAsync(sql);
}
});
_queue.Enqueue(task);
}
public IActionResult Get()
{
_logger.LogDebug("Writing to the log for Echo controller.");
var routes = GetRouteDetails(RouteData.Routers.OfType <RouteCollection>().FirstOrDefault());
var info = new
{
ServerTimeUTC = $"{DateTime.UtcNow}",
ServerName = Environment.MachineName,
ExecutingAssembly = Assembly.GetExecutingAssembly().FullName,
UserName = User.Identity.Name ?? "<NotSet>",
CustomerRepository = _customerRepo.GetType().AssemblyQualifiedName,
SettingsRepository = _settingsRepo.GetType().AssemblyQualifiedName,
SettingTypesRepository = _settingTypesRepo.GetType().AssemblyQualifiedName,
Routes = routes
};
return(Ok(info));
}
/// <summary>
/// Set's up the <see cref="InMemoryRepository{TItem}"/> to start listen to changes from the given <see cref="InMemoryRepository{TItem}"/>
/// </summary>
/// <exception cref="InvalidOperationException">Thrown when the <see cref="IRepository{TItem}"/> registered in DI is not a <see cref="InMemoryRepository{TItem}"/></exception>
public void Setup()
{
if (_repository is InMemoryRepository <TItem> inMemoryRepository)
{
inMemoryRepository.Changes += (args) =>
{
foreach (TItem changes in args.ItemChanges)
{
foreach (IItemChangeFeedProcessor <TItem> itemChangeFeedProcessor in _changeFeedProcessors)
{
itemChangeFeedProcessor.HandleAsync(changes, default).AsTask().Wait();
}
}
};
}
else
{
throw new InvalidOperationException(
$"A repository of type {_repository.GetType().Name} cannot be setup to work with the InMemoryChangeFeed");
}
}
private void ShouldFilterEntitiesByFilterSuccessfully <TEntity>(IRepository <TEntity> repository)
where TEntity : IEntity
{
string repositoryMessage = string.Format("Failed in {0}.", repository.GetType().Name);
Expression <Func <TEntity, bool> > filter = (f => f.Id > 0);
IList <TEntity> entities = repository.AsQueryable().Where(filter).ToList();
Assert.IsNotNull(entities, repositoryMessage + " Table is empty.");
Assert.Greater(entities.Count, 0, repositoryMessage + " Table is empty.");
IList <TEntity> entitieViaFilterBy = repository.AsQueryable(filter).ToList();
Assert.IsNotNull(entitieViaFilterBy);
Assert.AreEqual(entities.Count, entitieViaFilterBy.Count);
foreach (TEntity t in entities)
{
Assert.AreEqual(t, entitieViaFilterBy.FirstOrDefault(f => f.Id == t.Id),
repositoryMessage);
}
}
/// <summary>
/// Register a repository with the unit of work
/// </summary>
/// <param name="repository">A repository derived from irepository</param>
public void Register (IRepository repository)
{
_repositories.Add(repository.GetType().Name, repository);
}
private void ShowRepositoryType(IRepository <Person, string> repository)
{
RepositoryTypeLabel.Content = repository.GetType().FullName;
}
/// <summary>
/// Calls the <see cref="IRepository.Initialize"/> method for a repository
/// </summary>
public void InitializeRepository(IRepository repo, Type implementedInterface)
{
if (!_repositoryInitializers.ContainsKey(repo.RepositoryType))
{
throw new InvalidOperationException($"No initializer found for repository '{repo.GetType().FullName}'");
}
_repositoryInitializers[repo.RepositoryType].InitializeRepository(this, repo, implementedInterface);
}
internal void RefreshWorkers()
{
List <WorkerRecord> records;
using (IRepository repository = this.repositoryFactory.Create())
{
records = repository.GetWorkers(this.applicationName, this.address, this.name, null).ToList();
this.logger.Debug(
"Machine {0} ({1}) loaded {2} worker records from repository '{3}', using connection string '{4}'.",
this.name,
this.address,
records.Count,
repository.GetType().ToString(),
repository.ConnectionString);
}
lock (this)
{
List <Worker> newWorkers = new List <Worker>();
List <Worker> removeWorkers = new List <Worker>();
// Figure out which of the current workers get to stay alive.
foreach (Worker worker in this.workers)
{
WorkerRecord record = records.Where(r => r.Id == worker.Id).FirstOrDefault();
if (record != null)
{
newWorkers.Add(worker);
records.Remove(record);
}
else
{
removeWorkers.Add(worker);
}
}
// Prune orphaned current workers.
foreach (Worker worker in removeWorkers)
{
try
{
worker.Dispose();
}
catch (Exception ex)
{
this.logger.Error(ex);
}
}
// Create workers for all of the new records. Records corresponding
// to existing workers where pruned earlier.
foreach (WorkerRecord record in records)
{
Worker worker = null;
try
{
worker = new Worker(
this.applicationName,
record.Id.Value,
record.Name,
QueueNameFilters.Parse(record.QueueNames),
this.workerHeartbeat,
this.schedulerEnabled,
this.repositoryFactory,
this.logger);
newWorkers.Add(worker);
if (record.Status == WorkerStatus.Working || record.Startup == WorkerStartupType.Automatic)
{
worker.Start();
}
}
catch (Exception ex)
{
if (worker != null)
{
newWorkers.Remove(worker);
worker.Dispose();
}
this.logger.Error(ex);
}
}
// Ensure a default worker if necessary.
if (newWorkers.Count == 0 && this.ensureDefaultWorker)
{
Worker worker = this.CreateDefaultWorker();
newWorkers.Add(worker);
worker.Start();
}
this.workers = newWorkers;
this.logger.Debug("Machine {0} ({1}) refreshed its worker list and is now tracking {2} workers.", this.name, this.address, this.workers.Count);
}
}
public IEnumerable <TObject> GetLookup <TObject>(string identifier) where TObject : class
{
IRepository <TObject> repo = Unit.GetRepositoryFor <TObject>();
if (identifier.Contains("__"))
{
string collectionId = identifier.GetAfterLast("__");
if (!(repo is ICollectionRepository <TObject>))
{
throw new CodeShellHttpException(HttpStatusCode.ServiceUnavailable, $"Repository {repo.GetType().Name} must implement ICollectionRepository<{typeof(T).Name}> to use collections");
}
var AsgaRepo = (ICollectionRepository <TObject>)repo;
return(AsgaRepo.GetCollectionList(collectionId));
}
else
{
return(repo.Find(e => true));
}
}
/// <summary>
/// 强制转换指定仓库的数据提供程序为关系数据库的数据提供程。
/// 如果该仓库的 <see cref="IRepository.DataProvider"/> 不是此类型的子类，则会抛出异常。
/// </summary>
/// <param name="repository"></param>
/// <returns></returns>
public static RdbDataProvider Get(IRepository repository)
{
var dp = repository.DataProvider as RdbDataProvider;
if (dp == null)
{
throw new InvalidProgramException(string.Format(
"{0} 仓库类型使用的数据提供程序类型是 {1}，该类型不能转换为关系数据库的数据提供程序。",
repository.GetType(),
repository.DataProvider.GetType()
));
}
return dp;
}
public IUnitOfWork GetUnit(IRepository repo)
{
Type tipo = factory[repo.GetType().Name];
return (IUnitOfWork)Activator.CreateInstance(tipo);
}
