/// <summary>
/// Execute Query[T].Where(query).FirstOrDefault();
/// </summary>
public T FirstOrDefault <T>(Expression <Func <T, bool> > predicate, string collectionName = null)
{
using (var db = new LiteRepository(_configService.ConnectionString))
{
return(db.FirstOrDefault <T>(predicate, collectionName));
}
}
/// <summary>
/// Execute Query[T].Where(query).FirstOrDefault();
/// </summary>
public T FirstOrDefault <T>(Query query = null, string collectionName = null)
{
using (var db = new LiteRepository(_configService.ConnectionString))
{
return(db.FirstOrDefault <T>(query, collectionName));
}
}
public TModel GetById(int id)
{
using (var db = new LiteRepository(_connectionString))
{
return(db.FirstOrDefault <TModel>(x => x.Id == id && !x.Removed));
}
}
public Optional <Settings> GetSettingsForUser(string userName)
{
using (var repository = new LiteRepository(_connectionStringProvider.ConnectionString))
{
var entity = repository.FirstOrDefault <Settings>(p => p.UserName == userName);
return(entity == null ? Optional <Settings> .Empty() : Optional <Settings> .For(entity));
}
}
public Optional <InferenceProfile> GetProfileByName(string profileName)
{
using (var repository = new LiteRepository(_connectionStringProvider.ConnectionString))
{
var entity = repository.FirstOrDefault <InferenceProfile>(p => p.ProfileName == profileName);
return(entity == null ? Optional <InferenceProfile> .Empty() : Optional <InferenceProfile> .For(entity));
}
}
public Result <T> FirstOrDefault(Query query = null, string collectionName = null)
{
var result = new Result <T>();
try
{
result.ResultObject = _liteRepository.FirstOrDefault <T>(query, collectionName);
}
catch (Exception ex)
{
result.ResultCode = (int)ResultStatusCode.InternalServerError;
result.ResultMessage = "Hata Oluştu => " + ex;
result.ResultInnerMessage = "Hata Oluştu => " + ex.InnerException;
result.ResultStatus = false;
}
return(result);
}
public Security GetSecurity()
{
var security = _repository.FirstOrDefault <Security>();
if (security != null)
{
return(security);
}
security = new Security();
_repository.Insert(security, "security");
return(security);
}
public bool Remove(int id)
{
using (var db = new LiteRepository(_connectionString))
{
var entity = db.FirstOrDefault <TModel>(x => x.Id == id && !x.Removed);
if (entity == null)
{
return(false);
}
entity.Removed = true;
return(db.Update(entity));
}
}
private void AddTagIfNotExists(IEnumerable <TagDto> tags)
{
using (var db = new LiteRepository(_connectionString))
{
foreach (var tag in tags)
{
var exists = db.FirstOrDefault <TagDto>(x => x.NormalizedName == tag.NormalizedName);
if (exists == null)
{
db.Insert <TagDto>(tag);
}
}
}
}
public UserModel Get(Guid id)
{
if (id == Guid.Empty)
{
throw new ArgumentNullException(nameof(id));
}
var result = _instance.FirstOrDefault <UserModel>(x => x.Id == id);
if (result == null)
{
throw new Exception("No user found");
}
return(result);
}
static Database()
{
Repo = new LiteRepository("config.db");
DB = Repo.Database;
InternalOptions = Repo.FirstOrDefault <InternalOptions>();
if (InternalOptions == null)
{
InternalOptions = new InternalOptions();
return;
}
// check if InternalOptions are valid
InternalOptions.MaxModifications = Math.Max(InternalOptions.MaxModifications, 0);
InternalOptions.Duration = Math.Max(InternalOptions.Duration, MIN_DURATION);
Repo.Upsert(InternalOptions);
}
public T GetRawDtoById <T>(Id <T> id)
where T : IHasId <T>
{
return(repo.FirstOrDefault <T>(x => x.Id == id));
}
public T FirstOrDefault(Expression <Func <T, bool> > predicate)
{
return(_liteRepository.FirstOrDefault(predicate));
}
public PluginEntity GetPluginByGuid(Guid pluginGuid)
{
return(_repository.FirstOrDefault <PluginEntity>(p => p.Id == pluginGuid));
}
private static PdfFile GetPdf(this LiteRepository repo, string contentMd5)
{
var md5 = contentMd5.ToLowerInvariant();
return(repo.FirstOrDefault <PdfFile>(p => p.Md5 == md5));
}
public ModuleSettingsEntity GetByPluginGuid(Guid guid)
{
return(_repository.FirstOrDefault <ModuleSettingsEntity>(s => s.PluginGuid == guid));
}
public ProfileEntity Get(Guid id)
{
return(_repository.FirstOrDefault <ProfileEntity>(p => p.Id == id));
}
public DeviceEntity Get(string id)
{
return(_repository.FirstOrDefault <DeviceEntity>(s => s.Id == id));
}
public PluginSettingEntity GetByNameAndPluginGuid(string name, Guid pluginGuid)
{
return(_repository.FirstOrDefault <PluginSettingEntity>(p => p.Name == name && p.PluginGuid == pluginGuid));
}
public ModuleSettingsEntity GetByModuleId(string moduleId)
{
return(_repository.FirstOrDefault <ModuleSettingsEntity>(s => s.ModuleId == moduleId));
}
public async Task <TAggregate> Get(TKey key)
{
return(Db.FirstOrDefault <TAggregate>(a => a.Id == key));
}
public SurfaceEntity GetByName(string name)
{
return(_repository.FirstOrDefault <SurfaceEntity>(s => s.Name == name));
}
public Person Read(string id) => repository.FirstOrDefault <Person>(x => x.Id == id);
public Letter Read(string id) => repository.FirstOrDefault <Letter>(x => x.Id == id);
public Task <Session> GetSession(Guid sessionId)
{
return(Task.FromResult(repo.FirstOrDefault <Session>(x => x.SessionId == sessionId)));
}
