/// <summary>
/// 向数据源中添加帖子。
/// </summary>
/// <param name="dataFacade">数据源的外观。</param>
/// <param name="indexEntity">帖子索引实体对象。</param>
/// <param name="contentEntity">帖子内容对象。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// 或
/// <paramref name="indexEntity"/>为null
/// 或
/// <paramref name="contentEntity"/>为null
/// </exception>
/// <exception cref="DataFacadeException">数据源抛出了未经处理的异常</exception>
public static async Task <int> AddPost(this IDataFacade dataFacade,
PostEntity indexEntity, PostContentEntity contentEntity)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (indexEntity == null)
{
throw new ArgumentNullException(nameof(indexEntity));
}
if (contentEntity == null)
{
throw new ArgumentNullException(nameof(contentEntity));
}
// 将内容实体对象插入到数据源中。
await dataFacade.AddPostContentEntity(contentEntity);
// 将帖子索引实体对象插入到数据源中。
dataFacade.AddPostIndexEntity(indexEntity);
await dataFacade.CommitChanges();
return(indexEntity.Id);
}
public LessonService(IDataFacade facade, IFileHandler videoStream)
{
_lessonConv = new LessonConverter();
_secConv = new SectionConverter();
_facade = facade;
_videoStream = videoStream;
}
public SectionService(IDataFacade facade)
{
_sectionConv = new SectionConverter();
_crsConv = new CourseConverter();
_lesConv = new LessonConverter();
_facade = facade;
}
public void Init()
{
Mock<IDataFacade> mock = new Mock<IDataFacade>();
_facade = new Mock<IDataFacade>().Object;
}
/// <summary>
/// 打开包含给定帖子的给定索引处的图片的数据流。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="postId">帖子 ID</param>
/// <param name="imageIndex">图像索引</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// <paramref name="imageIndex"/>小于0 或 大于等于9
/// </exception>
public static async Task <Stream> OpenPostImage(this IDataFacade dataFacade, int postId, int imageIndex)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (imageIndex < 0 || imageIndex >= 9)
{
throw new ArgumentOutOfRangeException(nameof(imageIndex));
}
var(indexEntity, contentEntity) = await FindPost(dataFacade, postId);
if (imageIndex >= contentEntity.ImageIds.Length)
{
return(null);
}
var imageId = contentEntity.ImageIds[imageIndex];
if (imageId == null)
{
return(null);
}
return(await dataFacade.OpenImage(imageId.Value));
}
public CourseService(IDataFacade facade)
{
_crsConv = new CourseConverter();
_userConv = new UserConverter();
_secConverter = new SectionConverter();
_catConv = new CategoryConverter();
_lesConv = new LessonConverter();
_facade = facade;
}
/// <summary>
/// 获取给定帖子所属的板块 ID。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="commentId">帖子 ID</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// </exception>
/// <exception cref="CommentNotFoundException">给定的评论未找到时抛出</exception>
/// <exception cref="PostNotFoundException">给定的评论所属的帖子未找到时抛出</exception>
public static async Task <PostEntity> GetPostForComment(this IDataFacade dataFacade, int commentId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
var indexEntity = await dataFacade.Comments
.FirstOrDefaultAsync(e => e.Id == commentId && e.IsRemoved == false);
if (indexEntity == null)
{
throw new CommentNotFoundException();
}
int postId;
if (indexEntity.PostId != null)
{
// 当前评论是一级评论
postId = indexEntity.PostId.Value;
}
else
{
// 当前评论是二级评论
if (indexEntity.CommentId == null)
{
throw new CommentNotFoundException();
}
var parentEntity = await dataFacade.Comments
.FirstOrDefaultAsync(e => e.Id == indexEntity.CommentId.Value);
if (parentEntity == null)
{
throw new CommentNotFoundException();
}
if (parentEntity.PostId == null)
{
throw new CommentNotFoundException();
}
postId = parentEntity.PostId.Value;
}
var postEntity = await dataFacade.Posts
.FirstOrDefaultAsync(e => e.Id == postId);
if (postEntity == null)
{
throw new PostNotFoundException();
}
return(postEntity);
}
public AuthController(IWechatApiService wechatApiService,
IJwtService jwtService,
IDataFacade dataFacade,
ILogger <AuthController> logger)
{
_wechatApi = wechatApiService;
_jwt = jwtService;
_dataFacade = dataFacade;
_logger = logger;
}
/// <summary>
/// 实际的过程可能非常复杂，Assembler需要通过各种本地或远程方法
/// 获得一个 DTO 对象接口的引用，而且考虑到效率因素，DTO 本身应该相对
/// 客户程序而言，到实际外观对象更近，否则DTO的“打包”反而成为累赘。
/// </summary>
/// <returns></returns>
public IXmlDataDto CreateDto(IDataFacade facade)
{
if (facade == null)
{
throw new ArgumentNullException("facade");
}
IXmlDataDto dto = new XmlDataDto();
dto.Facade = facade;
return(dto);
}
private void ClientForm_Load(object sender, System.EventArgs e)
{
string configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
txtConfigFile.Text = configFile;
RemotingConfiguration.Configure(configFile, false);
string typeName = "Test.Rem.Common.IDataFacade";
remObj = (IDataFacade)RemHelper.CreateWellKnownType(typeName);
txtMessage.Text = "Hello world";
}
/// <summary>
/// 移除帖子图片。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="postId">帖子 ID。</param>
/// <param name="indexesToRemove">要移除的图片索引。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// 或
/// <paramref name="indexesToRemove"/>为null
/// </exception>
/// <exception cref="PostNotFoundException">指定的帖子不存在。</exception>
public static async Task RemovePostImages(this IDataFacade dataFacade,
int postId, IEnumerable <int> indexesToRemove)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (indexesToRemove == null)
{
throw new ArgumentNullException(nameof(indexesToRemove));
}
// TODO: 在这里添加代码对 indexesToRemove 进行验证
var indexEntity = await dataFacade.Posts
.Where(e => e.Id == postId)
.FirstOrDefaultAsync();
if (indexEntity == null)
{
throw new PostNotFoundException();
}
var contentId = new ObjectId(indexEntity.ContentId);
var contentEntity = await dataFacade.FindPostContentEntity(contentId);
var indexesToRemoveConcrete = indexesToRemove.ToArray();
// 删除图片数据
var removeTasks = new List <Task>();
foreach (var imageIndex in indexesToRemoveConcrete.Where(i => i >= 0 && i < contentEntity.ImageIds.Length))
{
var imageId = contentEntity.ImageIds[imageIndex];
if (imageId == null)
{
continue;
}
removeTasks.Add(dataFacade.RemoveImage(imageId.Value));
}
await Task.WhenAll(removeTasks);
// 更新内容实体对象
var imageSetDict = indexesToRemoveConcrete.ToDictionary <int, int, ObjectId?>(i => i, i => null);
await dataFacade.UpdatePostContentImageIds(contentId, imageSetDict);
// 更新索引实体对象中的最后更新时间戳
indexEntity.UpdateTime = DateTime.Now;
await dataFacade.CommitChanges();
}
/// <summary>
/// 当给定的用户不存在时，向数据源添加用户。返回用户实体对象。
/// </summary>
/// <param name="dataFacade">数据源外观。</param>
/// <param name="wechatId">用户的微信 ID。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/> 为 null
/// 或
/// <paramref name="wechatId"/> 为 null
/// </exception>
public static async Task <UserEntity> AddOrFindUserByWechatId(this IDataFacade dataFacade, string wechatId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (wechatId == null)
{
throw new ArgumentNullException(nameof(wechatId));
}
var existingEntity = await dataFacade.Users
.Where(u => u.WechatId == wechatId)
.FirstOrDefaultAsync();
if (existingEntity != null)
{
// 用户已经存在于数据源中
return(existingEntity);
}
// 用户在数据源中未找到
var userEntity = new UserEntity
{
WechatId = wechatId
};
try
{
dataFacade.AddUser(userEntity);
await dataFacade.CommitChanges();
return(userEntity);
}
catch (DataFacadeException)
{
// 重做用户查询
existingEntity = await dataFacade.Users
.Where(u => u.WechatId == wechatId)
.FirstOrDefaultAsync();
if (existingEntity != null)
{
return(existingEntity);
}
// 重做用户查询仍然无法找到用户
throw;
}
}
FindPosts(this IDataFacade dataFacade, int?region, int?userId, int page, int itemsPerPage)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (page < 0)
{
throw new ArgumentOutOfRangeException(nameof(page));
}
if (itemsPerPage <= 0)
{
throw new ArgumentOutOfRangeException(nameof(itemsPerPage));
}
// 构造查询
var query = dataFacade.Posts
.AsNoTracking()
.Where(e => e.IsRemoved == false);
if (region != null)
{
query = query.Where(e => e.PostRegionId == region.Value);
}
if (userId != null)
{
query = query.Where(e => e.AuthorId == userId.Value);
}
var indexEntities = await query.OrderByDescending(e => e.UpdateTime)
.Paginate(page, itemsPerPage)
.ToListAsync();
var contentEntities =
await dataFacade.FindPostContentEntities(indexEntities.Select(e => new ObjectId(e.ContentId)));
var contentDict = contentEntities.ToDictionary(e => e.Id);
return(indexEntities.Select(indexEntity =>
{
if (contentDict.TryGetValue(new ObjectId(indexEntity.ContentId), out var contentEntity))
{
return (indexEntity, contentEntity);
}
return (indexEntity, null);
}).ToList());
}
/// <summary>
/// 向数据源添加评论索引实体对象及其对应的内容实体对象。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="indexEntity">要添加的索引实体对象。</param>
/// <param name="contentEntity">要添加的内容实体对象。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="indexEntity"/>为null
/// 或
/// <paramref name="contentEntity"/>为null
/// </exception>
public static async Task AddPostComment(this IDataFacade dataFacade,
CommentEntity indexEntity, CommentContentEntity contentEntity)
{
if (indexEntity == null)
{
throw new ArgumentNullException(nameof(indexEntity));
}
if (contentEntity == null)
{
throw new ArgumentNullException(nameof(contentEntity));
}
dataFacade.AddCommentIndexEntity(indexEntity);
await dataFacade.CommitChanges();
await dataFacade.AddCommentContentEntity(contentEntity);
}
FindUserComments(this IDataFacade dataFacade, int userId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
var indexEntities = await dataFacade.Comments
.Where(e => e.AuthorId == userId && e.IsRemoved == false)
.ToListAsync();
var contentEntities = await dataFacade.FindCommentContentEntities(
indexEntities.Select(e => new ObjectId(e.ContentId)));
return(indexEntities.Zip(contentEntities, (ie, ce) => (ie, ce))
.ToList());
}
FindPostComments(this IDataFacade dataFacade, int postId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
// 获取所有一级评论
var indexEntitiesLv1 = await dataFacade.Comments
.Where(e => e.PostId == postId && e.IsRemoved == false)
.ToListAsync();
var contentEntitiesLv1 = await dataFacade.FindCommentContentEntities(
indexEntitiesLv1.Select(e => new ObjectId(e.ContentId)));
var indexEntitiesLv2 = new List <CommentEntity>();
var contentEntitiesLv2 = new List <CommentContentEntity>();
foreach (var entityLv1 in indexEntitiesLv1)
{
// 获取当前枚举到的一级评论下的所有二级评论
var indexEntitiesLv2Current = await dataFacade.Comments
.Where(e => e.CommentId == entityLv1.Id &&
e.IsRemoved == false)
.ToListAsync();
var contentEntitiesLv2Current = await dataFacade.FindCommentContentEntities(
indexEntitiesLv2Current.Select(e => new ObjectId(e.ContentId)));
indexEntitiesLv2.AddRange(indexEntitiesLv2Current);
contentEntitiesLv2.AddRange(contentEntitiesLv2Current);
}
// 将一级评论与二级评论进行扁平化处理
var indexEntities = indexEntitiesLv1;
indexEntities.AddRange(indexEntitiesLv2);
var contentEntities = contentEntitiesLv1;
contentEntitiesLv1.AddRange(contentEntitiesLv2);
return(indexEntities.Zip(contentEntities, (ie, ce) => (ie, ce))
.ToList());
}
/// <summary>
/// 查询给定的用户是否对给定的帖子进行了点赞。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="userId">用户 ID。</param>
/// <param name="postIds">帖子 ID。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// </exception>
public static async Task <List <bool> > IsUserVotedFor(this IDataFacade dataFacade,
int userId, IEnumerable <int> postIds)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
var userPosts = await dataFacade.UserVotePosts
.Where(e => e.UserId == userId)
.ToListAsync();
var userPostedPosts = userPosts.Select(x => x.PostId)
.ToHashSet();
return(postIds.Select(x => userPostedPosts.Contains(x))
.ToList());
}
/// <summary>
/// 获取指定帖子的创建者 ID。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="postId">帖子 ID。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// </exception>
/// <exception cref="PostNotFoundException">指定的帖子不存在</exception>
public static async Task <int> GetPostAuthorId(this IDataFacade dataFacade, int postId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
var indexEntity = await dataFacade.Posts
.AsNoTracking()
.Where(e => e.Id == postId && e.IsRemoved == false)
.FirstOrDefaultAsync();
if (indexEntity == null)
{
throw new PostNotFoundException();
}
return(indexEntity.AuthorId);
}
FindPost(this IDataFacade dataFacade, int postId)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
var indexEntity = await dataFacade.Posts
// 下面的语句中务必使用 e.IsRemoved == false 以正确引导 EFCore 解析查询
.FirstOrDefaultAsync(e => e.Id == postId && e.IsRemoved == false);
if (indexEntity == null)
{
// 没有在数据源中找到指定的帖子 ID
throw new PostNotFoundException();
}
var contentId = new ObjectId(indexEntity.ContentId);
var contentEntity = await dataFacade.FindPostContentEntity(contentId);
return(indexEntity, contentEntity);
}
/// <summary>
/// 删除指定的帖子。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="postId">要删除的帖子 ID。</param>
/// <param name="permanent">是否永久性地删除帖子数据</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="dataFacade"/>为null
/// </exception>
/// <exception cref="DataFacadeException">当数据源抛出了未经处理的异常时抛出</exception>
public static async Task RemovePost(this IDataFacade dataFacade, int postId, bool permanent = false)
{
if (dataFacade == null)
{
throw new ArgumentNullException(nameof(dataFacade));
}
if (permanent)
{
throw new NotImplementedException();
}
var indexEntity = await dataFacade.Posts
.Where(e => e.Id == postId && e.IsRemoved == false)
.FirstOrDefaultAsync();
if (indexEntity == null)
{
throw new PostNotFoundException();
}
indexEntity.IsRemoved = true;
await dataFacade.CommitChanges();
}
public PostController(IDataFacade dataFacade, IEntityFactory entityFactory, ILogger <PostController> logger)
{
_dataFacade = dataFacade ?? throw new ArgumentNullException(nameof(dataFacade));
_entityFactory = entityFactory ?? throw new ArgumentNullException(nameof(entityFactory));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public PersistentDataRetrievalStrategy(IDataFacade dataFacade, ChangeSetId lastedChangeSetId)
{
this.dataFacade = dataFacade;
this.lastedChangeSetId = lastedChangeSetId;
}
public ApplicationService(IDataFacade facade)
{
_facade = facade;
_applicationConv = new ApplicationConverter();
_userConv = new UserConverter();
}
public HomeController(IDataFacade dataFacade)
{
_dataFacade = dataFacade;
}
public BaseService()
{
_dataSource = new DataFacade(new DAL.ApplicationDbContext());
}
public BaseService(IDataFacade dataSource)
{
_dataSource = dataSource;
}
public HomeController(IDataFacade dataFacade)
{
_dataFacade = dataFacade;
}
public RegionsController(IDataFacade dataFacade,
ILogger <RegionsController> logger)
{
_dataFacade = dataFacade ?? throw new ArgumentNullException(nameof(dataFacade));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public BaseHandler(IDataFacade dataSource)
{
_dataSource = dataSource;
}
public ObjectFacade(IDataFacade dataFacade, ObjectTypeDescriptorRepository objectTypeDescriptorRepository, ICommandExecutor commandExecutor)
{
this.dataFacade = dataFacade;
this.commandExecutor = commandExecutor;
this.objectTypeDescriptorRepository = objectTypeDescriptorRepository;
}
public MainController(IDataFacade dataFacade)
{
this.dataFacade = dataFacade;
}
public BaseHandler()
{
_dataSource = new DataFacade(new Data.Entities.ApplicationDbContext());
}
public FileHandlingService(IDataFacade facade, IFileHandler fileHandler)
{
_facade = facade;
_fileHanlder = fileHandler;
_lesConv = new LessonConverter();
}
/// <summary>
/// 向给定的帖子上传图片。
/// </summary>
/// <param name="dataFacade"></param>
/// <param name="postId">帖子 ID。</param>
/// <param name="images">图片 ID 及对应图片的数据流工厂。</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="images"/>为null
/// </exception>
/// <exception cref="PostNotFoundException">
/// 指定的帖子不存在
/// 或
/// 帖子存在但其删除标记为true
/// </exception>
public static async Task UpdatePostImages(this IDataFacade dataFacade,
int postId, IReadOnlyDictionary <int, Func <Stream> > images)
{
if (images == null)
{
throw new ArgumentNullException(nameof(images));
}
// TODO: 在这里添加代码对 images 执行验证
var indexEntity = await dataFacade.Posts
// 下面的语句中务必使用 e.IsRemoved == true 以正确引导 EF Core 建立查询
.Where(e => e.Id == postId && e.IsRemoved == false)
.FirstOrDefaultAsync();
if (indexEntity == null)
{
// 指定的帖子不存在
throw new PostNotFoundException();
}
var contentId = new ObjectId(indexEntity.ContentId);
var contentEntity = await dataFacade.FindPostContentEntity(contentId);
// 删除已有的、被覆盖的图片数据
var removeTasks = new List <Task>();
foreach (var imageIndex in images.Keys.Where(i => i >= 0 && i < contentEntity.ImageIds.Length))
{
var imageId = contentEntity.ImageIds[imageIndex];
if (imageId == null)
{
continue;
}
removeTasks.Add(dataFacade.RemoveImage(imageId.Value));
}
await Task.WhenAll(removeTasks);
// 将图片上传至数据源
var imageIds = new ConcurrentDictionary <int, ObjectId?>();
var uploadTasks = new List <Task>();
foreach (var(index, imageDataStreamFactory) in images)
{
var imageDataStream = imageDataStreamFactory();
uploadTasks.Add(dataFacade.UploadImage(imageDataStream)
.ContinueWith((t, i) =>
{
imageDataStream.Close();
imageIds.TryAdd((int)i, t.Result);
}, index));
}
await Task.WhenAll(uploadTasks);
// 更新内容实体对象
await dataFacade.UpdatePostContentImageIds(contentId, imageIds);
// 更新索引实体对象中的上次更新时间戳
indexEntity.UpdateTime = DateTime.Now;
await dataFacade.CommitChanges();
}
public AuthService(IDataFacade facade, ITokenGenerator tokenGenerator)
{
_userConv = new UserConverter();
_tokenGenerator = tokenGenerator;
_facade = facade;
}
public PendingChangesDataRetrievalStrategy(IDataFacade dataFacade, UncommittedChangeSet pendingChanges)
{
this.dataFacade = dataFacade;
this.pendingChanges = pendingChanges;
}
