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);
}
