public static StatementAdded Create(StatementEntity newStatemnt) { return(new StatementAdded() { Entity = newStatemnt }); }
public async Task <Statement> Handle(StatementQuery request, CancellationToken cancellationToken) { var query = _context.Statements .Where(x => x.StatementId == request.StatementId && x.Voided == false); if (request.IncludeAttachments) { query = query.Include(x => x.Attachments) .Select(x => new StatementEntity() { StatementId = x.StatementId, FullStatement = x.FullStatement, Attachments = x.Attachments }); } else { query = query.Select(x => new StatementEntity() { StatementId = x.StatementId, FullStatement = x.FullStatement }); } StatementEntity statementEntity = await query.FirstOrDefaultAsync(cancellationToken); if (statementEntity == null) { return(null); } return(_mapper.Map <Statement>(statementEntity)); }
/// <summary> /// 映射Dto /// </summary> /// <typeparam name="T"></typeparam> /// <param name="statement"></param> /// <returns></returns> private T MapToDto <T>(StatementEntity statement) where T : MapDto { T dto = Mapper.Map <T>(statement); if (statement.CategoryId != null) { var category = _categoryRepo.Get(statement.CategoryId.Value) ?? throw new KnownException("账单分类数据查询失败!", ServiceResultCode.NotFound); dto.CategoryName = category.Name; dto.CategoryIconPath = _fileRepo.GetFileUrl(category.IconUrl); } else { if (statement.Type.Equals(StatementTypeEnum.transfer.ToString())) { dto.CategoryIconPath = _fileRepo.GetFileUrl("core/images/category/icon_transfer_64.png"); } else if (statement.Type.Equals(StatementTypeEnum.repayment.ToString())) { dto.CategoryIconPath = _fileRepo.GetFileUrl("core/images/category/icon_repayment_64.png"); } } var asset = _assetRepo.Get(statement.AssetId) ?? throw new KnownException("资产分类数据查询失败!", ServiceResultCode.NotFound); if (statement.TargetAssetId != null) { var targetAsset = _assetRepo.Get(statement.TargetAssetId.Value); dto.TargetAssetName = targetAsset.Name; } dto.AssetName = asset.Name; dto.TypeName = Switcher.StatementType(statement.Type); return(dto); }
public async Task <Unit> Handle(VoidStatementCommand request, CancellationToken cancellationToken) { IStatementBaseEntity voidingStatement = request.Statement; StatementRefEntity statementRef = voidingStatement.Object.StatementRef as StatementRefEntity; Guid?statementRefId = statementRef.StatementId; // Fetch statement to be voided StatementEntity voidedStatement = await _context.Statements .FirstOrDefaultAsync(x => x.StatementId == statementRefId, cancellationToken); // Upon receiving a Statement that voids another, the LRS SHOULD NOT* reject the request on the grounds of the Object of that voiding Statement not being present. if (voidedStatement == null) { await Task.CompletedTask; // Soft } // Any Statement that voids another cannot itself be voided. if (voidedStatement.Verb.Id == ExperienceApi.Data.Verbs.Voided) { await Task.CompletedTask; // Soft } // voidedStatement has been voided, return. if (voidedStatement.Voided) { throw new BadRequestException("should not void an already voided statement"); } voidedStatement.Voided = true; _context.Statements.Update(voidedStatement); return(await Unit.Task); }
public static StatementCreated Create(StatementEntity statement) { return(new StatementCreated() { Created = statement }); }
public static StatementVoided Create(StatementEntity voidingStatement, StatementEntity voidedStatement) { return(new StatementVoided() { Voiding = voidingStatement, Voided = voidedStatement }); }
public async Task <IActionResult> GetStatements([FromQuery] Queries.PagedStatementsQuery parameters, CancellationToken cancellationToken = default) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } ResultFormat format = parameters.Format ?? ResultFormat.Exact; if (!StringValues.IsNullOrEmpty(Request.Headers[HeaderNames.AcceptLanguage])) { format = ResultFormat.Canonical; } bool attachments = parameters.Attachments.GetValueOrDefault(); if (parameters.StatementId.HasValue || parameters.VoidedStatementId.HasValue) { IRequest <StatementEntity> requestQuery = null; if (parameters.StatementId.HasValue) { Guid statementId = parameters.StatementId.Value; requestQuery = Queries.StatementQuery.Create(statementId, attachments, format); } else if (parameters.VoidedStatementId.HasValue) { Guid voidedStatementId = parameters.VoidedStatementId.Value; requestQuery = Queries.VoidedStatemetQuery.Create(voidedStatementId, attachments, format); } StatementEntity statementEntity = await _mediator.Send(requestQuery, cancellationToken); if (statementEntity == null) { return(NotFound()); } var statement = _mapper.Map <Statement>(statementEntity); return(new StatementActionResult(statement, format)); } PagedStatementsResult pagedResult = await _mediator.Send(parameters, cancellationToken); var mappedStatements = _mapper.Map <IEnumerable <Statement> >(pagedResult.Statements); StatementsResult result = new StatementsResult() { Statements = new StatementCollection(mappedStatements) }; // Generate more url if (!string.IsNullOrEmpty(pagedResult.MoreToken)) { result.More = new Uri($"/xapi/statements?more={pagedResult.MoreToken}", UriKind.Relative); } return(new StatementsActionResult(result, format, attachments)); }
public async void ShouldReturnVoidedStatement() { // Arrange var mediatorMock = new Mock <IMediator>(); var authorityMock = new Mock <IClientContext>(); var createStatementHandler = new CreateStatementCommandHandler(_context, mediatorMock.Object, _mapper, authorityMock.Object); var voidStatementQueryHandler = new VoidedStatemetQueryHandler(_context, _mapper); var voidedStatementId = Guid.Parse("637E9E80-4B8D-4640-AC13-615C3E413568"); var statement = new Statement("{\"actor\":{\"objectType\":\"Agent\",\"name\":\"xAPI mbox\",\"mbox\":\"mailto:[email protected]\"},\"verb\":{\"id\":\"http://adlnet.gov/expapi/verbs/attended\",\"display\":{\"en-GB\":\"attended\",\"en-US\":\"attended\"}},\"object\":{\"objectType\":\"Activity\",\"id\":\"http://www.example.com/meetings/occurances/34534\"}}"); statement.Id = voidedStatementId; var voidingStatement = new Statement() { Actor = new Agent() { Mbox = new Mbox("mailto:[email protected]") }, Verb = new Verb() { Id = new Iri("http://adlnet.gov/expapi/verbs/voided") }, Object = new StatementRef() { Id = voidedStatementId }, }; voidingStatement.Object.As <StatementRef>().Id = statement.Id.Value; // Act Guid statementId = await createStatementHandler.Handle( CreateStatementCommand.Create(statement), CancellationToken.None ); // Create voiding statement Guid voidingStatementId = await createStatementHandler.Handle( CreateStatementCommand.Create(voidingStatement), CancellationToken.None ); // Query voided statement StatementEntity voidedStatement = await voidStatementQueryHandler.Handle( VoidedStatemetQuery.Create(voidedStatementId), CancellationToken.None ); // Assert mediatorMock.Verify(m => m.Publish(It.IsAny <StatementCreated>(), It.IsAny <CancellationToken>()), Times.AtLeast(2)); voidedStatement.ShouldNotBe(null); voidedStatement.VoidingStatementId.ShouldBe(voidingStatementId); }
public async Task UpdateAsync(StatementEntity statement) { var exist = await _statementRepo.Select.AnyAsync(s => s.Id == statement.Id && !s.IsDeleted); if (!exist) { throw new KnownException("没有找到该账单信息", ServiceResultCode.NotFound); } Expression <Func <StatementEntity, object> > ignoreExp = e => new { e.CreateUserId, e.CreateTime }; await _statementRepo.UpdateWithIgnoreAsync(statement, ignoreExp); }
/// <summary> /// Creates statement without saving to database /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns>Guid of the created statement</returns> public async Task <Guid> Handle(CreateStatementCommand request, CancellationToken cancellationToken) { await _mediator.Publish(StatementCreating.Create(), cancellationToken); // Prepare statement for mapping if (request.Statement.Id.HasValue) { bool any = await _context.Statements.AnyAsync(x => x.StatementId == request.Statement.Id, cancellationToken); if (any) { return(request.Statement.Id.Value); } } request.Statement.Stamp(); // Ensure statement version and stored date request.Statement.Version = request.Statement.Version ?? ApiVersion.GetLatest().ToString(); request.Statement.Stored = request.Statement.Stored ?? DateTimeOffset.UtcNow; if (request.Statement.Authority == null) { // Set authority before saving JSON encoded statement request.Statement.Authority = _clientContext.GetClientAuthority(); } else { // TODO: Validate authority var client = await _mediator.Send(ClientByAgentQuery.Create(request.Statement.Authority)); } // Start mapping statement StatementEntity newStatement = new StatementEntity(); newStatement.StatementId = request.Statement.Id.GetValueOrDefault(); newStatement.ClientId = _clientContext.GetClientId(); await HandleStatementBase(request.Statement, newStatement, cancellationToken); newStatement.Stored = request.Statement.Stored; newStatement.Timestamp = request.Statement.Timestamp; newStatement.Version = request.Statement.Version.ToString(); newStatement.FullStatement = request.Statement.ToJson(); _context.Statements.Add(newStatement); await _context.SaveChangesAsync(cancellationToken); await _mediator.Publish(StatementCreated.Create(newStatement), cancellationToken); return(newStatement.StatementId); }
public async Task <StatementDto> InsertAsync(StatementEntity statement) { var entity = await _statementRepo.InsertAsync(statement); if (entity == null) { throw new KnownException("新增账单失败!", ServiceResultCode.Failed); } var statementDto = MapToDto <StatementDto>(entity); return(statementDto); }
public bool PutStatement(Guid?statementId, Statement statement, out HttpStatusCode statusCode) { statusCode = HttpStatusCode.Conflict; statement.Id = statementId; if (statement.Id.HasValue) { if (CheckIfExists(statementId)) { return(true); } } if (statement.Verb.Id == KnownVerbs.Voided) { StatementRef stRf = statement.Object as StatementRef; if (IsVoidedOrVoiding(stRf.Id)) { return(true); } } statement.Stamp(); // Ensure statement version and stored date statement.Version = statement.Version ?? ApiVersion.GetLatest().ToString(); statement.Stored = statement.Stored ?? DateTimeOffset.UtcNow; if (statement.Authority == null) { // Set authority before saving JSON encoded statement var agent = new Agent(); agent.Mbox = new Mbox("mailto:" + "*****@*****.**"); agent.Name = "Manu"; statement.Authority = agent; } //to do map to Statement Entity StatementEntity newStatement = new StatementEntity(); newStatement.Id = statement.Id; newStatement.Stored = statement.Stored; newStatement.Version = statement.Version.ToString(); newStatement.FullStatement = statement.ToJson(); StoreStatement(newStatement); return(false); }
public void ShouldReturn_StatementsResult_WithAgent() { var entity = new StatementEntity() { Verb = new VerbEntity() { Id = "https://google.com" } }; var iri = Iri.Parse(entity.Verb.Id); var statement = new Statement(); _mapper.Map(entity, statement); statement.ShouldNotBeNull(); statement.Verb.ShouldNotBeNull(); statement.Verb.Id.ShouldNotBeNull(); }
public async Task Handle(StatementCreated notification, CancellationToken cancellationToken) { var entity = notification.Created; if (entity.Verb.Id == VoidedVerb) { if (entity.ObjectType == EntityObjectType.StatementRef) { Guid statementId = entity.ObjectId; StatementEntity statement = await _context.Statements .Include(x => x.Verb) .SingleOrDefaultAsync(x => x.StatementId == statementId , cancellationToken); if (statement != null && statement.Verb.Id != VoidedVerb) { statement.VoidingStatementId = entity.StatementId; await _context.SaveChangesAsync(cancellationToken); } } } else { // Detect if current statement has already been voided var voidingStatement = await _context.Statements.SingleOrDefaultAsync(x => x.ObjectType == EntityObjectType.StatementRef && x.ObjectId == entity.StatementId && x.Verb.Id == VoidedVerb , cancellationToken); if (voidingStatement != null) { entity.VoidingStatement = entity; await _context.SaveChangesAsync(cancellationToken); } } }
public void StoreStatement(StatementEntity newStatement) { }
public async Task <IActionResult> PostStatement(IFormFile excelFile, [FromForm] StatementEntity newStatement) { var statement = dataService.TreatStatement(excelFile, newStatement.nom, newStatement.rib, newStatement.mois, newStatement.annee); return(Ok(statement)); }
/// <summary> /// Creates statement without saving to database /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns>Guid of the created statement</returns> public async Task <Guid> Handle(CreateStatementCommand request, CancellationToken cancellationToken) { // Prepare statement for mapping if (request.Statement.Id.HasValue) { bool any = await _context.Statements.AnyAsync(x => x.StatementId == request.Statement.Id, cancellationToken).ConfigureAwait(false); if (any) { return(request.Statement.Id.Value); } } request.Statement.Stamp(); // Ensure statement version and stored date request.Statement.Version = request.Statement.Version ?? ApiVersion.GetLatest().ToString(); request.Statement.Stored = request.Statement.Stored ?? DateTimeOffset.UtcNow; if (request.Statement.Authority == null) { // TODO: Map group? request.Statement.Authority = _mapper.Map <Agent>(_authorityContext.Authority); } else { // TODO: Validate authority } // Start mapping statement StatementEntity newStatement = new StatementEntity(); newStatement.StatementId = request.Statement.Id.GetValueOrDefault(); newStatement.Verb = (VerbEntity)await _mediator.Send(UpsertVerbCommand.Create(request.Statement.Verb), cancellationToken).ConfigureAwait(false); newStatement.Actor = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Actor), cancellationToken).ConfigureAwait(false); newStatement.Authority = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Authority), cancellationToken).ConfigureAwait(false); if (request.Statement.Context != null) { newStatement.Context = _mapper.Map <ContextEntity>(request.Statement.Context); ContextEntity context = newStatement.Context; if (context.Instructor != null) { context.Instructor = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Context.Instructor), cancellationToken).ConfigureAwait(false); } if (context.Team != null) { context.Team = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create(request.Statement.Context.Team), cancellationToken).ConfigureAwait(false); } } var objType = request.Statement.Object.ObjectType; newStatement.Object = new StatementObjectEntity(); if (objType == ObjectType.Activity) { newStatement.Object.Activity = (ActivityEntity)await _mediator.Send(UpsertActivityCommand.Create((Activity)request.Statement.Object), cancellationToken).ConfigureAwait(false); } else if (objType == ObjectType.Agent || objType == ObjectType.Group) { newStatement.Object.Agent = (AgentEntity)await _mediator.Send(UpsertActorCommand.Create((Agent)request.Statement.Object), cancellationToken).ConfigureAwait(false); } else if (objType == ObjectType.SubStatement) { newStatement.Object.SubStatement = (SubStatementEntity)await _mediator.Send(CreateSubStatementCommand.Create((SubStatement)request.Statement.Object), cancellationToken).ConfigureAwait(false); } else if (objType == ObjectType.StatementRef) { newStatement.Object.StatementRef = _mapper.Map <StatementRefEntity>((StatementRef)request.Statement.Object); } if (request.Statement.Result != null) { newStatement.Result = _mapper.Map <ResultEntity>(request.Statement.Result); } newStatement.Stored = request.Statement.Stored; newStatement.Timestamp = request.Statement.Timestamp; newStatement.Version = request.Statement.Version.ToString(); newStatement.FullStatement = request.Statement.ToJson(); _context.Statements.Add(newStatement); // await _context.SaveChangesAsync(cancellationToken); await _mediator.Publish(StatementAdded.Create(newStatement), cancellationToken).ConfigureAwait(false); if (request.Persist) { await _context.SaveChangesAsync(cancellationToken).ConfigureAwait(false); } return(newStatement.StatementId); }
/// <summary> /// Creates statement without saving to database /// </summary> /// <param name="request"></param> /// <param name="cancellationToken"></param> /// <returns>Guid of the created statement</returns> public async Task <Guid> Handle(CreateStatementCommand request, CancellationToken cancellationToken) { if (request.Statement.Id.HasValue) { int count = await _context.Statements.CountAsync(x => x.StatementId == request.Statement.Id, cancellationToken); if (count > 0) { return(request.Statement.Id.Value); } } request.Statement.Stamp(); // Ensure statement version and stored date request.Statement.Version = request.Statement.Version ?? ApiVersion.GetLatest().ToString(); request.Statement.Stored = request.Statement.Stored ?? DateTimeOffset.UtcNow; if (request.Statement.Authority == null) { request.Statement.Authority = _authorityContext.Authority; } else { // TODO: Validate authority } StatementEntity newStatement = _mapper.Map <StatementEntity>(request.Statement); newStatement.Verb = (VerbEntity)await _mediator.Send(MergeVerbCommand.Create(request.Statement.Verb), cancellationToken).ConfigureAwait(false); newStatement.Actor = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Statement.Actor), cancellationToken).ConfigureAwait(false); newStatement.Authority = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Statement.Authority), cancellationToken).ConfigureAwait(false); if (newStatement.Context != null) { var context = newStatement.Context; if (context.Instructor != null) { context.Instructor = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Statement.Context.Instructor), cancellationToken); } if (context.Team != null) { context.Team = (AgentEntity)await _mediator.Send(MergeActorCommand.Create(request.Statement.Context.Team), cancellationToken); } } var objType = newStatement.Object.ObjectType; if (objType == EntityObjectType.Activity) { newStatement.Object.Activity = (ActivityEntity)await _mediator.Send(MergeActivityCommand.Create((IActivity)request.Statement.Object)); } else if (objType == EntityObjectType.Agent || objType == EntityObjectType.Group) { newStatement.Object.Agent = (AgentEntity)await _mediator.Send(MergeActorCommand.Create((IAgent)request.Statement.Object)); } else if (objType == EntityObjectType.SubStatement) { newStatement.Object.SubStatement = (SubStatementEntity)await _mediator.Send(CreateSubStatementCommand.Create((ISubStatement)request.Statement.Object)); } else if (objType == EntityObjectType.StatementRef) { // It's already mapped from automapper // TODO: Additional logic should be performed here } newStatement.FullStatement = request.Statement.ToJson(); _context.Statements.Add(newStatement); await _mediator.Publish(StatementAdded.Create(newStatement), cancellationToken); return(newStatement.StatementId); }