private async Task <TResponse <IEnumerable <string> > > GetListValue(int clientId,
string sqlQuery)
{
try
{
var result = await ReadOnlyRepository.QueryAsync <string>(sqlQuery, new
{
ClientId = clientId
});
if (result.IsSuccess)
{
if (result.Data != null &&
result.Data.Any())
{
return(await Ok(result.Data));
}
return(await Ok(new List <string>().AsEnumerable()));
}
return(await Fail <IEnumerable <string> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <string> >(exception));
}
}
protected override async Task <System.Linq.IQueryable <Blog> > CreateFilteredQueryAsync(BlogListInput input)
{
if (input.IncludeDetails)
{
if (input.UseIncludeFilter)
{
// https://docs.microsoft.com/en-us/ef/core/querying/related-data/eager#filtered-include
return((await ReadOnlyRepository.GetQueryableAsync())
.Include(x => x.Posts
// Note: Ensures the collection is not loaded in to memory prior to evaluation (not really required here though)
.AsQueryable()
.Where(x => x.ConcurrencyStamp != null && x.ExtraProperties != null)
)
// see: https://docs.microsoft.com/en-us/ef/core/querying/single-split-queries#split-queries-1
// Note: Default behaviour for collections. Creates a filtered SQL query for root 'Blog' entity, then another Query for filtered Blog.Posts when they are projected/accessed.
//.AsSplitQuery()
// Note: Default behaviour for on-to-one entities. Forces all data to be fetched in one query (and generates a 'LEFT JOIN' on Posts table). Can cause cartesian explosion when working with collections.
//.AsSingleQuery()
);
}
return(await ReadOnlyRepository.WithDetailsAsync(b => b.Posts));
}
return(await ReadOnlyRepository.GetQueryableAsync());
}
public async Task <TResponse <bool> > IsOriginAllowed(string origin)
{
try
{
var origins = await ReadOnlyRepository.QueryAsync <string>(SqlQuery.CLIENT_CORS_ORIGIN_GET_ALL);
if (origins.IsSuccess)
{
if (origins.Data != null &&
origins.Data.Any())
{
if (origins.Data.Contains(origin))
{
return(await Ok(true));
}
}
return(await Fail <bool>(string.Empty));
}
return(await Fail <bool>(origins.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public void Run(CancellationToken token)
{
Dir = string.IsNullOrEmpty(Dir)
? baseDir
: FilePath.FilePath.Expand(Dir);
if (!Directory.Exists(Dir))
{
throw new DirectoryNotFoundException(Dir);
}
var dbs = Directory.GetFiles(Dir, "*.sqlite");
if (!dbs.Any())
{
throw new AriesException($"{Dir}以下にDbがありませんでした。");
}
foreach (var db in dbs)
{
token.ThrowIfCancellationRequested();
var repo = new ReadOnlyRepository(Path.Combine(baseDir, db));
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"Path: {db}");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(repo.GetParameter());
Console.WriteLine("---------------------------------------------------------------------");
}
}
protected virtual void ProcessChildren(Item item, IMap map, ReadOnlyRepository repository, IList list)
{
foreach (Item child in item.Children)
{
AddItem(child, map, repository, list);
}
}
/// <summary>
/// 是否微信已经认证过
/// </summary>
/// <param name="code">用户code</param>
/// <returns></returns>
public WeixinAuthUserStatus IsWeiXinAuth(string code)
{
var weixinauthresult = new WeixinAuthUserStatus()
{
AuthStatus = false, UserId = null
};
if (string.IsNullOrEmpty(code))
{
return(weixinauthresult);
}
var weixinuserid = GetWeixinAuthUserId(code);
if (string.IsNullOrEmpty(weixinuserid))
{
return(weixinauthresult);
}
var user = ReadOnlyRepository.Get(e => e.WeiXinAuthId == weixinuserid);
if (user == null)
{
return(weixinauthresult);
}
weixinauthresult.AuthStatus = true;
weixinauthresult.UserId = user.UserBackendId;
return(weixinauthresult);
}
private async Task <List <CrmCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <CrmCacheModel>(SqlQuery.GET_ALL_CRM);
if (result.IsSuccess)
{
if (result.Data != null)
{
var crms = result.Data.ToList();
await DistributedCache.Set(_cacheKey,
crms);
return(await Task.FromResult(crms));
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
private async Task <TResponse <bool> > CanInsert(InsertRoleModel request)
{
try
{
var checkValidName = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_NAME, new
{
request.Name
});
if (checkValidName.IsSuccess)
{
if (checkValidName.Data != null)
{
return(await Fail <bool>(ErrorEnum.RoleNameHasExist.GetStringValue()));
}
else
{
return(await Ok(true));
}
}
return(await Fail <bool>(checkValidName.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
/// <summary>
/// 查询分站
/// </summary>
/// <param name="totalCount">总数量</param>
/// <param name="recentCount">最近数量</param>
/// <param name="recentDate">最近数量计算时间起</param>
/// <param name="groupdArea">分组区域</param>
public void QuerySubstation(out int totalCount, out int recentCount, out DateTime recentDate, out Dictionary <string, List <string> > groupdArea)
{
string subStationRole = "SubStation";
IQueryable <UserBackendDbModel> query = ReadOnlyRepository.Query(e => e.Roles.Contains(subStationRole));
var dbResult = query.Select(e => new { Areas = e.Areas, CreateDate = e.CreateDate, });
HashSet <string> areas = new HashSet <string>();
foreach (var area in dbResult)
{
foreach (var item in area.Areas.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
areas.Add(item);
}
}
//City = AreaService.GetCityModelFromAreaCode(e).Name
var substationModel = areas.OrderBy(e => e).Select(e => new
{
Code = e,
/*
* Povince = AreaService.GetAreaName(e.Substring(0, 2) + "0000"),
* City = AreaService.GetAreaName(e),
*/
Povince = AreaService.GetProvinceModelFromCode(e).Name,
City = AreaService.GetCityModelFromAreaCode(e).Name +
(e.EndsWith("00") ? "" : AreaService.GetAreaViewByCode(e).Name),
});
totalCount = substationModel.Count();
var recentD = DateTime.Now.AddDays(-7);
recentCount = dbResult.Where(e => e.CreateDate > recentD).Count();
groupdArea = substationModel.GroupBy(e => e.Povince).ToDictionary(g => g.Key, g => g.ToList().Select(e => e.City).ToList());
recentDate = dbResult.OrderByDescending(e => e.CreateDate).Select(e => e.CreateDate).FirstOrDefault();
}
private async Task <TResponse <int> > CheckInvalidPassword(string username,
string password)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_PASSWORD, new
{
Username = username,
Password = Sha512(password)
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(result.Data));
}
return(await Fail <int>(ErrorEnum.PasswordNotMatch.GetStringValue()));
}
return(await Fail <int>(result.Message));
}
catch (Exception exception)
{
return(await Fail <int>(exception));
}
}
private async Task <TResponse <bool> > CheckInvalidSite(int userId,
int siteId)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_CHECK_BY_SITE, new
{
UserId = userId,
SiteId = siteId
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.UserNotBelongThisSite.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <TResponse <bool> > CheckUsernameHasExist(string username)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <int>(SqlQuery.USER_FIND_BY_USERNAME, new
{
Username = username
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.UsernameHasNotExist.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <TResponse <IEnumerable <PersistedGrantDto> > > GetAllBySubjectId(string subjectId)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <IEnumerable <PersistedGrantDto> >(SqlQuery.PERSISTED_GRANT_GET_BY_SUBJECT_ID, new
{
SubjectId = subjectId
});
if (result.IsSuccess)
{
if (result.Data != null)
{
return(await Ok(result.Data));
}
return(await Fail <IEnumerable <PersistedGrantDto> >(ErrorEnum.PersistedGrantHasNotExist.GetStringValue()));
}
return(await Fail <IEnumerable <PersistedGrantDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <PersistedGrantDto> >(exception));
}
}
public async Task <TResponse <PersistedGrantDto> > GetByKey(string key)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <PersistedGrantDto>(SqlQuery.PERSISTED_GRANT_GET_BY_KEY, new
{
Key = key
});
if (result.IsSuccess)
{
if (result.Data != null)
{
return(await Ok(result.Data));
}
return(await Fail <PersistedGrantDto>(ErrorEnum.PersistedGrantHasNotExist.GetStringValue()));
}
return(await Fail <PersistedGrantDto>(result.Message));
}
catch (Exception exception)
{
return(await Fail <PersistedGrantDto>(exception));
}
}
private async Task <TResponse <IEnumerable <ClientPropertyDto> > > GetClientProperties(int clientId)
{
try
{
var result = await ReadOnlyRepository.QueryAsync <ClientPropertyDto>(SqlQuery.CLIENT_PROPERTY_GET_BY_CLIENT_ID, new
{
ClientId = clientId
});
if (result.IsSuccess)
{
if (result.Data != null &&
result.Data.Any())
{
return(await Ok(result.Data));
}
return(await Ok(new List <ClientPropertyDto>().AsEnumerable()));
}
return(await Fail <IEnumerable <ClientPropertyDto> >(result.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <ClientPropertyDto> >(exception));
}
}
public async Task <TResponse <UserAgent> > GetByName(string name)
{
try
{
string sqlQuery = @"SELECT * FROM dbo.UserAgent WHERE Name=@Name";
var userAgent = await ReadOnlyRepository.QueryFirstOrDefaultAsync <UserAgent>(sqlQuery,
new
{
Name = name
});
if (userAgent.IsSuccess)
{
if (userAgent.Data != null)
{
return(await Ok(userAgent.Data));
}
return(await Fail <UserAgent>(""));
}
return(await Fail <UserAgent>(userAgent.Message));
}
catch (Exception exception)
{
return(await Fail <UserAgent>(exception));
}
}
public async Task <TResponse <IEnumerable <RoleModel> > > GetAll(int userId,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var result = await ReadOnlyRepository.QueryAsync <RoleModel>(SqlQuery.ROLE_GET_ALL);
if (result.IsSuccess)
{
return(await Ok(result.Data));
}
return(await Fail <IEnumerable <RoleModel> >(result.Message));
}
return(await Fail <IEnumerable <RoleModel> >(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <IEnumerable <RoleModel> >(exception));
}
}
public async Task <TResponse <RoleModel> > GetByUserId(int userId)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_USER_ID, new
{
UserId = userId
});
if (result.IsSuccess)
{
if (result.Data != null)
{
return(await Ok(result.Data));
}
return(await Fail <RoleModel>(ErrorEnum.ROLE_HAS_NOT_EXIST.GetStringValue()));
}
return(await Fail <RoleModel>(result.Message));
}
catch (Exception exception)
{
return(await Fail <RoleModel>(exception));
}
}
private async Task <List <TaskPriorityCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <TaskPriorityCacheModel>(SqlQuery.GET_ALL_TASK_PRIORITY);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
private async Task <List <InvoiceStatusCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <InvoiceStatusCacheModel>(SqlQuery.GET_ALL_INVOICE_STATUS);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
protected override void ProcessChildren(Item item, IMap map, ReadOnlyRepository repository, IList list)
{
//Add self.
AddItem(item, map, repository, list);
base.ProcessChildren(item, map, repository, list);
}
private async Task <List <ReceiptDescriptionCacheModel> > LoadFromDb()
{
try
{
var result = await ReadOnlyRepository.QueryAsync <ReceiptDescriptionCacheModel>(SqlQuery.GET_ALL_RECEIPT_DESCRIPTION);
if (result.IsSuccess)
{
if (result.Data != null)
{
await DistributedCache.Set(_cacheKey,
result.Data.ToList());
return(result.Data.ToList());
}
}
else
{
_logger.Info(result.Message);
}
}
catch (Exception exception)
{
_logger.Info(exception);
}
return(null);
}
/// <summary>
/// Get Site By Id
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task <TResponse <SiteModel> > GetById(int id)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <SiteModel>(
SqlQuery.SITE_GET_BY_ID, new
{
Id = id
});
if (result.IsSuccess)
{
if (result.Data != null)
{
return(await Ok(result.Data));
}
return(await Fail <SiteModel>(ErrorEnum.SiteIdHasNotExist.GetStringValue()));
}
return(await Fail <SiteModel>(result.Message));
}
catch (Exception exception)
{
return(await Fail <SiteModel>(exception));
}
}
public async Task <TResponse <UserModel> > GetByUsername(string username)
{
try
{
var result = await ReadOnlyRepository.QueryFirstOrDefaultAsync <UserModel>(SqlQuery.USER_FIND_BY_USERNAME,
new
{
Username = username
});
if (result.IsSuccess)
{
if (result.Data != null)
{
return(await Ok(result.Data));
}
return(await Fail <UserModel>(ErrorEnum.USER_HAS_NOT_EXIST.GetStringValue()));
}
return(await Fail <UserModel>(result.Message));
}
catch (Exception exception)
{
return(await Fail <UserModel>(exception));
}
}
private async Task <TResponse <bool> > CanDelete(int id)
{
try
{
var role = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_GET_BY_ID,
new
{
Id = id
});
if (role.IsSuccess)
{
if (role.Data != null)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.ROLE_HAS_NOT_EXIST.GetStringValue()));
}
return(await Fail <bool>(role.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public bool validar(String contraseña)
{
ReadOnlyRepository r =new ReadOnlyRepository(_session);
if(r.First<CuentaDeUsuario>( (CuentaDeUsuario cuenta)=> cuenta.Name == "Test name").Password.CompareTo(Encryptor.Encrypt(contraseña))==0)
return true;
return false;
}
private async Task <TResponse <bool> > CanInsert(InsertProductModel request)
{
try
{
var product = await ReadOnlyRepository.QueryFirstOrDefaultAsync <ProductModel>(SqlQuery.PRODUCT_FIND_BY_NAME,
new
{
request.Name
});
if (product.IsSuccess)
{
if (product.Data != null)
{
return(await Fail <bool>(ErrorEnum.PRODUCT_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(product.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public void AddEntityTest()
{
var tmp = Path.Combine(Path.GetTempPath(), "Ptolemy.Repository", "Test");
Directory.CreateDirectory(tmp);
var root = Path.Combine(tmp, "dbRoot");
Directory.CreateDirectory(root);
var pe = GenerateDummyParameters().First();
try {
using var hub = new DbHub(CancellationToken.None, root, 1, null);
var key = hub.AddDb(pe);
hub.AddEntity(key, new ResultEntity {
Sweep = 1, Seed = 2,
Signal = "signal", Time = 0,
Value = 1
});
hub.CloseDb(key);
var repo = new ReadOnlyRepository(Path.Combine(root, $"{key}.sqlite"));
Func <Map <string, decimal>, bool> f = m => m[$"signal/{0M:E5}"] == 1;
var res = repo.Aggregate(
CancellationToken.None, new[] { "signal" }, new[] { f }, 2, new (long start, long end)[] { (1, 10) },
private async Task <TResponse <bool> > CanInsert(InsertUserModel request)
{
try
{
var user = await ReadOnlyRepository.QueryFirstOrDefaultAsync <UserModel>(SqlQuery.USER_FIND_BY_USERNAME,
new
{
request.Username
});
if (user.IsSuccess)
{
if (user.Data != null)
{
return(await Fail <bool>(ErrorEnum.USERNAME_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(user.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
private async Task <TResponse <bool> > CanUpdate(UpdateRoleModel request)
{
try
{
var role = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_FIND_BY_NAME_AND_ID,
new
{
request.Name,
request.Id
});
if (role.IsSuccess)
{
if (role.Data != null)
{
return(await Fail <bool>(ErrorEnum.ROLE_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(role.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
protected override async Task <IQueryable <BasketItem> > CreateFilteredQueryAsync(GetBasketItemListDto input)
{
var userId = input.UserId ?? CurrentUser.GetId();
return((await ReadOnlyRepository.GetQueryableAsync())
.Where(item => item.UserId == userId && item.BasketName == input.BasketName));
}
public void Initialize()
{
_fixture = new Fixture();
_fixture.Customize(new AutoMoqCustomization());
_dbSet = _fixture.Freeze<StubDbSet<StubModel>>();
_context = _fixture.Freeze<Mock<IApplicationContext>>();
_context.Setup(a => a.Set<StubModel>()).Returns(_dbSet);
_repository = _fixture.CreateAnonymous<ReadOnlyRepository<StubModel, int>>();
}
public object ResolveEntityPropertyValue(string rawValue, Type propertyType)
{
if (rawValue.IsNotEmpty())
{
Match imageMatch = Regex.Match(rawValue, RegexPattern);
if (imageMatch.Success && imageMatch.Groups["imageid"].Value.IsGuid())
{
Guid imageId = new Guid(imageMatch.Groups["imageid"].Value);
ReadOnlyRepository repository = new ReadOnlyRepository();
return repository.Get<Image>(imageId);
}
}
return null;
}
public object ResolveEntityPropertyValue(string rawValue, Type propertyType)
{
var result = new File();
if (rawValue.IsNotEmpty())
{
Match imageMatch = Regex.Match(rawValue, RegexPattern);
if (imageMatch.Success && imageMatch.Groups["mediaid"].Value.IsGuid())
{
Guid imageId = new Guid(imageMatch.Groups["mediaid"].Value);
ReadOnlyRepository repository = new ReadOnlyRepository();
File image = repository.Get<File>(imageId);
result = image ?? new File();
}
}
return result;
}
