public bool RevokeUserAccess(GuidEntity entity, Guid groupId)
{
var task = AvoidAsyncDeadlock(() => RevokeUserAccessAsync(entity, groupId));
var response = task.Result;
return(response.StatusCode == HttpStatusCode.OK);
}
public void Multi_Type_Entity_Test()
{
var intEntity = new IntEntity()
{
Id = 1
};
var longEntity = new LongEntity()
{
Id = 1
};
var stringEntity = new StringEntity()
{
Id = "A"
};
var guidEntity = new GuidEntity()
{
Id = new Guid()
};
var userEntity = new UserEntity()
{
Id = { No = 1, Code = "AA" }
};
Assert.NotNull(intEntity);
Assert.NotNull(longEntity);
Assert.NotNull(stringEntity);
Assert.NotNull(guidEntity);
Assert.NotNull(userEntity);
}
public Access GetAccess(GuidEntity entity)
{
var task = AvoidAsyncDeadlock(() => GetAccessAsync(entity));
var response = task.Result;
return(response.Data);
}
/// <summary>
/// Get user or groups access permissions.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public Task <MojioResponse <Access> > GetAccessAsync(GuidEntity entity)
{
string controller = Map[typeof(Access)];
var request = GetRequest(Request(controller, entity.Type, entity.Id), Method.GET);
return(RequestAsync <Access>(request));
}
public bool GrantUserAccess(GuidEntity entity, Guid userId, Permissions flags = Permissions.View)
{
var task = AvoidAsyncDeadlock(() => GrantUserAccessAsync(entity, userId, flags));
var response = task.Result;
return(response.StatusCode == HttpStatusCode.OK);
}
/// <summary>
/// 根据id获取数据
/// </summary>
/// <param name="ContentId">内容id</param>
/// <returns></returns>
public async System.Threading.Tasks.Task <CL_Content> GetInfo(GuidEntity ContentId)
{
string sql = $"SELECT * FROM {ReName($"{Prefix}Content")} WHERE {ReName("ContentId")}=@ContentId;";
List <DbParameter> parlist = new List <DbParameter>();
parlist.Add(CreateParam("@ContentId", ContentId));
return(await QueryInfo(sql, $"GetInfo:{ContentId}", DataReader, parlist.ToArray()));
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="ContentId">内容id</param>
/// <returns></returns>
public async System.Threading.Tasks.Task <bool> Delete(GuidEntity ContentId)
{
string sql = $"DELETE FROM {ReName($"{Prefix}Content")} WHERE {ReName("ContentId")}=@ContentId;";
List <DbParameter> parlist = new List <DbParameter>();
parlist.Add(CreateParam("@ContentId", ContentId));
return(await ExecuteNonQueryMem(sql, parlist.ToArray()));
}
//TODO:: allow end users to add more events to the throttle than the default
// battery and fuel events.
public bool hasThrottle(GuidEntity entity)
{
return (EventTypes.Contains(EventType.LowBattery) &&
((Event)entity).EventType == EventType.LowBattery)
||
(EventTypes.Contains(EventType.LowFuel) &&
((Event)entity).EventType == EventType.LowFuel);
}
public void Equalses()
{
Guid nid = Guid.NewGuid();
GuidEntity a = new GuidEntity(nid);
GuidEntity b = new GuidEntity(nid);
Assert.True(a == b);
}
/// <summary>
/// 更新内容id
/// </summary>
/// <param name="ContentId">内容id</param>
/// <returns></returns>
public async System.Threading.Tasks.Task <bool> UpdateWithContentId(GuidEntity ContentId)
{
if (IsEmpty())
{
return(false);
}
entity.ContentId = ContentId;
return(await Update());
}
/// <summary>
/// 根据id获取数据
/// </summary>
/// <param name="serviceProvider">依赖注入接口</param>
/// <param name="ContentId">内容id</param>
/// <returns></returns>
public static async System.Threading.Tasks.Task <ContentContext> GetInfo(
IServiceProvider serviceProvider,
GuidEntity ContentId)
{
Culture.BusyData.Content db = new Culture.BusyData.Content(serviceProvider);
Culture.Entity.CL_Content entity = await db.GetInfo(ContentId);
return(new ContentContext(serviceProvider, entity, db));
}
/// <summary>
/// Revoke user access to entity.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="groupId">The group or user identifier.</param>
/// <returns></returns>
public Task <MojioResponse> RevokeUserAccessAsync(GuidEntity entity, Guid groupId)
{
string action = Map[typeof(Access)];
var request = GetRequest(Request(action, entity.Type, entity.Id, "users"), Method.DELETE);
request.AddParameter("userId", groupId);
return(RequestAsync(request));
}
/// <summary>
/// 处理函数
/// </summary>
/// <param name="serviceProvider">依赖注入接口</param>
/// <param name="ContentId">内容id</param>
/// <param name="Title">标题</param>
/// <param name="Image">首图</param>
/// <param name="Content">内容</param>
/// <param name="Status">状态 0：未审核 1:审核通过 2：拒绝</param>
/// <param name="Updated">更新时间</param>
/// <param name="CreateUid">创建用户</param>
/// <param name="CreateIP">建立IP</param>
/// <param name="CreateDate">建立时间</param>
/// <param name="Introduce">介绍</param>
public static async System.Threading.Tasks.Task <ContentContext> Sub(
IServiceProvider serviceProvider,
GuidEntity ContentId
, StringEntity Title
, StringEntity Image
, StringEntity Content
, short Status
, System.DateTime Updated
, GuidEntity CreateUid
, StringEntity CreateIP
, System.DateTime CreateDate
, StringEntity Introduce
)
{
ContentContext operinfo = await GetInfo(serviceProvider, ContentId);
if (operinfo.IsEmpty())
{
Culture.Entity.CL_Content info = new Culture.Entity.CL_Content
{
ContentId = operinfo.CreateGuid(),
Title = Title,
Image = Image,
Content = Content,
Status = Status,
Recycle = 0,
Updated = Updated,
CreateUid = CreateUid,
CreateIP = CreateIP,
CreateDate = CreateDate,
Introduce = Introduce,
};
operinfo.SetEntity(info);
if (!await operinfo.Insert())
{
throw new System.Exception("添加失败!");
}
}
else
{
operinfo.GetEntity().Title = Title;
operinfo.GetEntity().Image = Image;
operinfo.GetEntity().Content = Content;
operinfo.GetEntity().Status = Status;
operinfo.GetEntity().Updated = Updated;
operinfo.GetEntity().CreateUid = CreateUid;
operinfo.GetEntity().CreateIP = CreateIP;
operinfo.GetEntity().CreateDate = CreateDate;
operinfo.GetEntity().Introduce = Introduce;
if (!await operinfo.Update())
{
throw new System.Exception("更改失败!");
}
}
return(operinfo);
}
/// <summary>
/// 获取(空信息)
/// </summary>
/// <param name="serviceProvider">依赖注入接口</param>
/// <param name="page">分页信息</param>
/// <param name="ContentId"></param>
/// <returns></returns>
public static async System.Threading.Tasks.Task <List <CommContext> > GetListPageWithContentID(
IServiceProvider serviceProvider,
PageInfo page,
GuidEntity ContentId)
{
Culture.BusyData.Comm db = new Culture.BusyData.Comm(serviceProvider);
return(await TransList(
db.GetListPageWithContentID(page, ContentId),
t => { return new CommContext(serviceProvider, t, db); }));
}
public void should_insert_entity_with_null_value()
{
var entity = new GuidEntity();
_guidTable1.Insert(entity);
entity.Id.ShouldNotEqual(Guid.Empty);
var newEntity = _guidTable1.First(x => x.Id == entity.Id);
newEntity.Name.ShouldBeNull();
}
/// <summary>
/// 根据状态获取信息列表
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="page"></param>
/// <param name="createid"></param>
/// <param name="status"></param>
/// <returns></returns>
public static async System.Threading.Tasks.Task <List <ContentContext> > GetListPageCreateID(
IServiceProvider serviceProvider,
PageInfo page,
GuidEntity createid,
int status)
{
Culture.BusyData.Content db = new Culture.BusyData.Content(serviceProvider);
return(await TransList(
db.GetListPageCreateID(page, createid, status),
t => { return new ContentContext(serviceProvider, t, db); }));
}
public Permissions GetUserAccess(GuidEntity entity, Guid userId)
{
#pragma warning disable 0618
var access = GetAccess(entity);
#pragma warning restore 0618
var query = from u in access.Users
where u.UserId.Equals(userId)
select u.Permissions;
return(query.FirstOrDefault());
}
/// <summary>
/// 根据分页参数获取数据列表
/// </summary>
/// <param name="page">分页信息</param>
/// <param name="uid">审核状态</param>
/// <param name="status">状态</param>
/// <returns></returns>
public async System.Threading.Tasks.Task <List <CL_Content> > GetListPageCreateID(
PageInfo page,
GuidEntity uid,
int status)
{
return(await QueryListPage(
$"{ReName($"{Prefix}Content")}",
$"GetListPageCreateID:{uid}:status:{status}",
DataReader,
page,
$"{ReName("CreateUid")} = '{uid}' AND {Recycle()} AND {ReName("Status")} = {status} "));
}
/// <summary>
/// 获取内容的评论信息
/// </summary>
/// <param name="page"></param>
/// <param name="ContentId"></param>
/// <returns></returns>
public async System.Threading.Tasks.Task <List <CL_Comm> > GetListPageWithContentID(
PageInfo page,
GuidEntity ContentId)
{
return(await QueryListPage(
$"{ReName($"{Prefix}Comm")}",
$"GetListPageWithContentID:{ContentId}",
DataReader,
page,
$"{ReName("ContentId")} = '{ContentId}'",
"*",
$"order by {ReName("CreateDate")} DESC"));
}
/// <summary>
/// Set user access to entity with given permissions.
/// </summary>
/// <param name="entity">The entity.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="flags">The permission flags.</param>
/// <returns></returns>
public Task <MojioResponse> SetUserAccessAsync(GuidEntity entity, Guid userId, Permissions flags = Permissions.View)
{
string action = Map[typeof(Access)];
var request = GetRequest(Request(action, entity.Type, entity.Id, "users"), Method.POST);
var access = new UserAccess()
{
UserId = userId,
Permissions = flags
};
request.AddBody(access);
return(RequestAsync(request));
}
public void Insert_Entity_Test()
{
var entity = new GuidEntity();
entity.Name = "oh hai";
entity.Values.Add("timestamp", DateTime.Now);
entity.Values.Add("hide", true);
_guidTable1.Insert(entity);
entity.Id.ShouldNotEqual(Guid.Empty);
var newEntity = _guidTable1.First(x => x.Id == entity.Id);
newEntity.Name.ShouldEqual("oh hai");
newEntity.Values["timestamp"].ToString().ShouldEqual(entity.Values["timestamp"].ToString());
newEntity.Values["hide"].ShouldEqual(entity.Values["hide"]);
}
public void GeneratedGuidConstraint_DoNotChangeGuidOnUpdate()
{
GeneratedGuidConstraint <GuidEntity> constraint =
new GeneratedGuidConstraint <GuidEntity>(e => e.Field);
GuidEntity entity = new GuidEntity();
Guid originalValue = entity.Field;
IExecutionContext context =
new FakeExecutionContext(operationType: OperationType.Update);
constraint.Apply(entity, context);
Assert.AreEqual(originalValue, entity.Field);
}
/// <summary>
/// 处理函数
/// </summary>
/// <param name="serviceProvider">依赖注入接口</param>
/// <param name="CommID">评论id</param>
/// <param name="ContentId">内容id</param>
/// <param name="Content">内容</param>
/// <param name="Updated">更新时间</param>
/// <param name="CreateUid">创建用户</param>
/// <param name="CreateIP">建立IP</param>
/// <param name="CreateDate">建立时间</param>
public static async System.Threading.Tasks.Task <CommContext> Sub(
IServiceProvider serviceProvider,
GuidEntity CommID
, GuidEntity ContentId
, StringEntity Content
, System.DateTime Updated
, GuidEntity CreateUid
, StringEntity CreateIP
, System.DateTime CreateDate
)
{
CommContext operinfo = await GetInfo(serviceProvider, CommID);
if (operinfo.IsEmpty())
{
Culture.Entity.CL_Comm info = new Culture.Entity.CL_Comm
{
CommID = operinfo.CreateGuid(),
ContentId = ContentId,
Content = Content,
Recycle = 0,
Updated = Updated,
CreateUid = CreateUid,
CreateIP = CreateIP,
CreateDate = CreateDate,
};
operinfo.SetEntity(info);
if (!await operinfo.Insert())
{
throw new System.Exception("添加失败!");
}
}
else
{
operinfo.GetEntity().ContentId = ContentId;
operinfo.GetEntity().Content = Content;
operinfo.GetEntity().Updated = Updated;
operinfo.GetEntity().CreateUid = CreateUid;
operinfo.GetEntity().CreateIP = CreateIP;
operinfo.GetEntity().CreateDate = CreateDate;
if (!await operinfo.Update())
{
throw new System.Exception("更改失败!");
}
}
return(operinfo);
}
/// <summary>
/// 验证
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
protected override bool Vail(AuthorizationHandlerContext context)
{
if (base.Vail(context))
{
return(true);
}
if (context.User.Identity.AuthenticationType.Contains(AuthenticationScheme))
{
GuidEntity uid = context.User.FindFirstValue(NetCore.Macro.COOKIESLOGIN_UID);
if (uid == GuidEntity.Empty)
{
return(false);
}
return(true);
}
return(false);
}
public void Entity_No_Equals_Test()
{
var intEntity = new IntEntity()
{
Id = 1
};
var longEntity = new LongEntity()
{
Id = 1
};
Assert.False(intEntity.Equals(longEntity));
var guidEntity1 = new GuidEntity();
var guidEntity2 = new GuidEntity();
Assert.False(guidEntity1.Equals(guidEntity2));
}
public Permissions MyAccess(GuidEntity entity)
{
var task = AvoidAsyncDeadlock(() => GetAccessAsync(entity));
var response = task.Result;
var access = response.Data;
if (access.Users == null)
{
return(Permissions.None);
}
#pragma warning disable 0618
var query = from u in access.Users
where u.UserId.Equals(CurrentUser.Id)
select u.Permissions;
#pragma warning restore 0618
return(query.FirstOrDefault());
}
public void Entity_IsTransient_Test()
{
var intEntity = new IntEntity();
Assert.True(intEntity.IsTransient());
var longEntity = new LongEntity();
Assert.True(longEntity.IsTransient());
var stringEntity = new StringEntity();
Assert.True(stringEntity.IsTransient());
var guidEntity = new GuidEntity();
Assert.True(guidEntity.IsTransient());
var userEntity = new UserEntity();
Assert.True(userEntity.IsTransient());
}
public override bool isThrottled(GuidEntity entity)
{
return hasThrottle(entity) &&
base.isThrottled(entity);
}
public override bool UpdateThrottle(GuidEntity entity)
{
return hasThrottle(entity) &&
Throttle != null;
}
public virtual bool UpdateThrottle(GuidEntity entity)
{
return Throttle != null;
}
public virtual bool isThrottled(GuidEntity entity)
{
// Now earlier than the next broadcast.
return (Throttle != null &&
NextAllowedBroadcast != null &&
DateTime.Compare(DateTime.UtcNow,
NextAllowedBroadcast.GetValueOrDefault()) < 0);
}
public bool SetStored(GuidEntity entity, string key, string value)
{
return(SetStored(entity.GetType(), entity.Id, key, value));
}
public bool DeleteStored(GuidEntity entity, string key)
{
return(DeleteStored(entity.GetType(), entity.Id, key));
}
public string GetStored(GuidEntity entity, string key)
{
return(GetStored(entity.GetType(), entity.Id, key));
}
