/// <summary>
/// 保存配置实例。
/// </summary>
/// <param name="site">当前配置实例。</param>
/// <returns>返回数据结果。</returns>
public virtual async Task <DataResult> SaveAsync(SiteBase site)
{
var adapter = site.ToStore();
if (adapter.SiteId > 0)
{
return(DataResult.FromResult(await _sdb.UpdateAsync(adapter), DataAction.Updated));
}
if (await IsDuplicatedAsync(site))
{
return(DataResult.FromResult(await _sdb.UpdateAsync(x => x.SiteKey == adapter.SiteKey, new { adapter.SiteName, adapter.UpdatedDate, adapter.SettingValue }), DataAction.Updated));
}
return(DataResult.FromResult(await _sdb.BeginTransactionAsync(async db =>
{
if (!await db.CreateAsync(adapter))
{
return false;
}
site.SiteId = adapter.SiteId;
foreach (var handler in _handlers)
{
if (!await handler.OnCreateAsync(db, site))
{
return false;
}
}
return true;
}), DataAction.Created));
}
/// <summary>
/// 保存配置实例。
/// </summary>
/// <param name="site">当前配置实例。</param>
/// <returns>返回数据结果。</returns>
public virtual DataResult Save(SiteBase site)
{
var adapter = site.ToStore();
if (adapter.SiteId > 0)
{
return(DataResult.FromResult(_sdb.Update(adapter), DataAction.Updated));
}
if (IsDuplicated(site))
{
return(DataResult.FromResult(_sdb.Update(x => x.SiteKey == adapter.SiteKey, new { adapter.SiteName, adapter.UpdatedDate, adapter.SettingValue }), DataAction.Updated));
}
return(DataResult.FromResult(_sdb.BeginTransaction(db =>
{
if (!db.Create(adapter))
{
return false;
}
site.SiteId = adapter.SiteId;
foreach (var handler in _handlers)
{
if (!handler.OnCreate(db, site))
{
return false;
}
}
return true;
}), DataAction.Created));
}
/// <summary>
/// 修改昵称。
/// </summary>
/// <param name="id">用户Id。</param>
/// <param name="nickName">昵称。</param>
/// <returns>返回修改结果。</returns>
public async Task <DataResult> ChangeNickNameAsync(int id, string nickName)
{
if (await Repository.AnyAsync(x => x.UserId != id && x.NickName == nickName))
{
return(DataAction.Duplicate);
}
return(DataResult.FromResult(await Repository.UpdateAsync(x => x.UserId == id, new { nickName, updateddate = DateTimeOffset.Now }), DataAction.Updated));
}
/// <summary>
/// 返回数据库操作结果，如果成功刷新缓存。
/// </summary>
/// <param name="result">操作结果。</param>
/// <param name="success">成功枚举。</param>
/// <returns>返回数据操作结果。</returns>
protected DataResult Result(bool result, DataAction success)
{
if (result)
{
_cache.Remove(_cacheKey);
}
return(DataResult.FromResult(result, success));
}
/// <summary>
/// 保存对象实例。
/// </summary>
/// <param name="model">模型实例对象。</param>
/// <returns>返回保存结果。</returns>
public virtual DataResult Save(TModel model)
{
if (IsDuplicated(model))
{
return(DataAction.Duplicate);
}
if (Context.Any(model.Id))
{
return(DataResult.FromResult(Context.Update(model), DataAction.Updated));
}
return(DataResult.FromResult(Context.Create(model), DataAction.Created));
}
/// <summary>
/// 保存标签。
/// </summary>
/// <param name="tag">标签实例。</param>
/// <returns>返回保存结果。</returns>
public DataResult Save(Tag tag)
{
if (_tags.Any(x => x.Name == tag.Name && x.Id != tag.Id))
{
return(DataAction.Duplicate);
}
if (tag.Id > 0)
{
return(DataResult.FromResult(_tags.Update(tag), DataAction.Updated));
}
return(DataResult.FromResult(_tags.Create(tag), DataAction.Created));
}
/// <summary>
/// 保存参数。
/// </summary>
/// <param name="argument">参数实例对象。</param>
/// <returns>返回保存结果。</returns>
public async Task <DataResult> SaveArgumentAsync(TaskArgument argument)
{
if (await _args.AnyAsync(x => x.TaskId == argument.TaskId && x.Argument == argument.Argument))
{
return(DataAction.Duplicate);
}
if (argument.Id > 0)
{
return(DataResult.FromResult(await _args.UpdateAsync(argument), DataAction.Updated));
}
return(DataResult.FromResult(await _args.CreateAsync(argument), DataAction.Created));
}
/// <summary>
/// 保存对象实例。
/// </summary>
/// <param name="model">模型实例对象。</param>
/// <returns>返回保存结果。</returns>
/// <param name="cancellationToken">取消标识。</param>
public virtual async Task <DataResult> SaveAsync(TModel model, CancellationToken cancellationToken = default)
{
if (await IsDuplicatedAsync(model, cancellationToken))
{
return(DataAction.Duplicate);
}
if (Context.Any(model.Id))
{
return(DataResult.FromResult(await Context.UpdateAsync(model, cancellationToken), DataAction.Updated));
}
return(DataResult.FromResult(await Context.CreateAsync(model, cancellationToken), DataAction.Created));
}
/// <summary>
/// 保存应用程序。
/// </summary>
/// <param name="application">当前应用程序。</param>
/// <returns>返回数据库操作结果。</returns>
public virtual async Task <DataResult> SaveAsync(Application application)
{
if (await _context.AnyAsync(
x => x.Id != application.Id && x.Name == application.Name && x.UserId == application.UserId))
{
return(DataAction.Duplicate);
}
if (application.Id > 0)
{
return(DataResult.FromResult(await _context.UpdateAsync(application), DataAction.Updated));
}
return(DataResult.FromResult(await _context.CreateAsync(application), DataAction.Created));
}
/// <summary>
/// 保存应用程序。
/// </summary>
/// <param name="application">当前应用程序。</param>
/// <returns>返回数据库操作结果。</returns>
public virtual DataResult Save(Application application)
{
if (_context.Any(
x => x.Id != application.Id && x.Name == application.Name && x.UserId == application.UserId))
{
return(DataAction.Duplicate);
}
if (application.Id > 0)
{
return(DataResult.FromResult(_context.Update(application), DataAction.Updated));
}
return(DataResult.FromResult(_context.Create(application), DataAction.Created));
}
/// <summary>
/// 保存实例。
/// </summary>
/// <param name="model">模型实例对象。</param>
/// <returns>返回执行结果。</returns>
public override DataResult Save(Archive model)
{
if (IsDulicate(model))
{
return(DataAction.Duplicate);
}
if (model.Id > 0)
{
model.UpdatedDate = DateTime.Now;
return(DataResult.FromResult(Database.UpdateTagable <Archive, ArchiveTagIndexer>(model), DataAction.Updated));
}
return(DataResult.FromResult(Database.CreateTagable <Archive, ArchiveTagIndexer>(model), DataAction.Created));
}
/// <summary>
/// 保存对象实例。
/// </summary>
/// <param name="model">模型实例对象。</param>
/// <returns>返回保存结果。</returns>
public virtual DataResult Save(TModel model)
{
if (IsDuplicated(model))
{
return(DataAction.Duplicate);
}
if (Context.Any(x => x.SiteId == model.SiteId && x.Id.Equals(model.Id)))
{
return(DataResult.FromResult(Update(model), DataAction.Updated));
}
return(DataResult.FromResult(Create(model), DataAction.Created));
}
/// <summary>
/// 删除当前实例。
/// </summary>
/// <param name="ids">网站Id列表。</param>
/// <returns>返回删除结果。</returns>
public virtual DataResult Delete(int[] ids)
{
var result = Refresh(Context.BeginTransaction(db =>
{
foreach (var eventHandler in _eventHandlers)
{
if (!eventHandler.OnDelete(db, ids))
{
return(false);
}
}
return(db.Delete(x => x.Id.Included(ids)));
}, 600), ids);
return(DataResult.FromResult(result, DataAction.Created));
}
/// <summary>
/// 删除当前实例。
/// </summary>
/// <param name="ids">网站Id列表。</param>
/// <returns>返回删除结果。</returns>
public virtual async Task <DataResult> DeleteAsync(int[] ids)
{
var result = Refresh(await Context.BeginTransactionAsync(async db =>
{
foreach (var eventHandler in _eventHandlers)
{
if (!await eventHandler.OnDeleteAsync(db, ids))
{
return(false);
}
}
return(await db.DeleteAsync(x => x.Id.Included(ids)));
}, 600), ids);
return(DataResult.FromResult(result, DataAction.Created));
}
/// <summary>
/// 删除网站。
/// </summary>
/// <param name="siteId">网站ID。</param>
/// <returns>返回删除结果。</returns>
public virtual async Task <DataResult> DeleteAsync(int siteId)
{
return(DataResult.FromResult(await _sdb.BeginTransactionAsync(async db =>
{
foreach (var handler in _handlers)
{
if (!await handler.OnDeleteAsync(db, siteId))
{
return false;
}
}
if (!await db.DeleteAsync(siteId))
{
return false;
}
return true;
}), DataAction.Deleted));
}
/// <summary>
/// 删除网站。
/// </summary>
/// <param name="siteId">网站ID。</param>
/// <returns>返回删除结果。</returns>
public virtual DataResult Delete(int siteId)
{
return(DataResult.FromResult(_sdb.BeginTransaction(db =>
{
foreach (var handler in _handlers)
{
if (!handler.OnDelete(db, siteId))
{
return false;
}
}
if (!db.Delete(siteId))
{
return false;
}
return true;
}), DataAction.Deleted));
}
/// <summary>
/// 保存短信。
/// </summary>
/// <param name="client">客户端发送器名称<see cref="ISmsClient.Name"/>。</param>
/// <param name="phoneNumbers">电话号码，多个电话号码使用“,”分开。</param>
/// <param name="message">电子邮件字符串。</param>
/// <returns>返回保存结果。</returns>
public virtual async Task <DataResult> SaveAsync(string client, string phoneNumbers, string message)
{
if (!_clients.TryGetValue(client, out var smsClient))
{
return(Resources.SMSClientNotFound);
}
var msg = new SmsMessage();
msg.Client = client;
msg.Message = message;
msg.Count = message.GetSmsCount();
var numbers = phoneNumbers
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.Distinct()
.ToList();
return(DataResult.FromResult(await Context.BeginTransactionAsync(async db =>
{
foreach (var number in numbers)
{
msg.Id = 0;
msg.PhoneNumber = number;
msg.ServiceType = number.GetServiceType();
var prev = await db.AsQueryable()
.Where(x => x.HashKey == msg.HashKey)
.OrderByDescending(x => x.CreatedDate)
.FirstOrDefaultAsync();
if (prev != null && smsClient.IsDuplicated(msg, prev))
{
continue;
}
await db.CreateAsync(msg);
}
return true;
}), DataAction.Created));
}
/// <summary>
/// 保存短信。
/// </summary>
/// <param name="client">客户端发送器名称<see cref="ISmsClient.Name"/>。</param>
/// <param name="phoneNumbers">电话号码，多个电话号码使用“,”分开。</param>
/// <param name="message">电子邮件字符串。</param>
/// <returns>返回保存结果。</returns>
public virtual DataResult Save(string client, string phoneNumbers, string message)
{
if (!_clients.TryGetValue(client, out var smsClient))
{
return(Resources.SMSClientNotFound);
}
var note = new Note();
note.Client = client;
note.Message = message;
var numbers = phoneNumbers
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.Distinct()
.ToList();
return(DataResult.FromResult(Context.BeginTransaction(db =>
{
foreach (var number in numbers)
{
note.Id = 0;
note.PhoneNumber = number;
var prev = db.AsQueryable()
.Where(x => x.HashKey == note.HashKey)
.OrderByDescending(x => x.CreatedDate)
.FirstOrDefault();
if (prev != null && smsClient.IsDuplicated(note, prev))
{
continue;
}
db.Create(note);
}
return true;
}), DataAction.Created));
}
/// <summary>
/// 通过唯一Id删除对象实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="id">唯一Id。</param>
/// <returns>返回删除结果。</returns>
public virtual DataResult Delete(int siteId, TKey id)
{
return(DataResult.FromResult(Context.Delete(x => x.SiteId == siteId && x.Id.Equals(id)), DataAction.Deleted));
}
/// <summary>
/// 根据条件删除实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="expression">条件表达式。</param>
/// <returns>返回删除结果。</returns>
public virtual DataResult Delete(int siteId, Expression <Predicate <TModel> > expression)
{
return(DataResult.FromResult(Context.Delete(expression.AndAlso(siteId)), DataAction.Deleted));
}
/// <summary>
/// 根据条件更新特定的实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="expression">条件表达式。</param>
/// <param name="fields">更新对象。</param>
/// <returns>返回更新结果。</returns>
public virtual DataResult Update(int siteId, Expression <Predicate <TModel> > expression, object fields)
{
return(DataResult.FromResult(Context.Update(expression.AndAlso(siteId), fields), DataAction.Updated));
}
/// <summary>
/// 通过唯一Id删除对象实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="ids">唯一Id集合。</param>
/// <returns>返回删除结果。</returns>
public virtual DataResult Delete(int siteId, IEnumerable <TKey> ids)
{
return(DataResult.FromResult(Context.Delete(x => x.SiteId == siteId && x.Id.Included(ids)), DataAction.Deleted));
}
/// <summary>
/// 删除非法名称。
/// </summary>
/// <param name="ids">非法名称Id。</param>
/// <returns>返回删除结果。</returns>
public DataResult Delete(int[] ids)
{
return(DataResult.FromResult(_context.Delete(x => x.Id.Included(ids)), DataAction.Deleted));
}
/// <summary>
/// 删除非法名称。
/// </summary>
/// <param name="id">非法名称Id。</param>
/// <returns>返回删除结果。</returns>
public DataResult Delete(int id)
{
return(DataResult.FromResult(_context.Delete(x => x.Id == id), DataAction.Deleted));
}
/// <summary>
/// 更新用户的相关列。
/// </summary>
/// <param name="id">用户Id。</param>
/// <param name="user">用户实例列。</param>
/// <returns>返回保存结果。</returns>
public async Task <DataResult> UpdateAsync(int id, object user)
{
return(DataResult.FromResult(await Repository.UpdateAsync(x => x.UserId == id, user), DataAction.Updated));
}
/// <summary>
/// 根据条件删除实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="expression">条件表达式。</param>
/// <param name="cancellationToken">取消标识。</param>
/// <returns>返回删除结果。</returns>
public virtual async Task <DataResult> DeleteAsync(int siteId, Expression <Predicate <TModel> > expression,
CancellationToken cancellationToken = default)
{
return(DataResult.FromResult(await Context.DeleteAsync(expression.AndAlso(siteId), cancellationToken), DataAction.Deleted));
}
/// <summary>
/// 通过唯一Id删除对象实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="id">唯一Id。</param>
/// <param name="cancellationToken">取消标识。</param>
/// <returns>返回删除结果。</returns>
public virtual async Task <DataResult> DeleteAsync(int siteId, TKey id, CancellationToken cancellationToken = default)
{
return(DataResult.FromResult(await Context.DeleteAsync(x => x.SiteId == siteId && x.Id.Equals(id), cancellationToken), DataAction.Deleted));
}
/// <summary>
/// 根据条件更新特定的实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="id">唯一Id。</param>
/// <param name="fields">更新对象。</param>
/// <returns>返回更新结果。</returns>
public virtual DataResult Update(int siteId, TKey id, object fields)
{
return(DataResult.FromResult(Context.Update(x => x.SiteId == siteId && x.Id.Equals(id), fields), DataAction.Updated));
}
/// <summary>
/// 通过唯一Id删除对象实例。
/// </summary>
/// <param name="siteId">网站Id。</param>
/// <param name="ids">唯一Id集合。</param>
/// <param name="cancellationToken">取消标识。</param>
/// <returns>返回删除结果。</returns>
public virtual async Task <DataResult> DeleteAsync(int siteId, IEnumerable <TKey> ids,
CancellationToken cancellationToken = default)
{
return(DataResult.FromResult(await Context.DeleteAsync(x => x.SiteId == siteId && x.Id.Included(ids), cancellationToken),
DataAction.Deleted));
}
/// <summary>
/// 删除参数。
/// </summary>
/// <param name="ids">参数Id集合。</param>
/// <returns>返回删除结果。</returns>
public async Task <DataResult> DeleteArgumentAsync(string ids)
{
var ints = ids.SplitToInt32();
return(DataResult.FromResult(await _args.DeleteAsync(x => x.Id.Included(ints)), DataAction.Deleted));
}
