public override void OnActionExecuting(HttpActionContext context)
{
var supported = ApiVersion.GetSupported();
try
{
if (!context.Request.Headers.Contains(ApiHeaders.XExperienceApiVersion))
{
throw new Exception($"Missing '{ApiHeaders.XExperienceApiVersion}' header.");
}
IEnumerable <string> headerValues = context.Request.Headers.GetValues(ApiHeaders.XExperienceApiVersion);
string requestVersion = headerValues.FirstOrDefault();
if (string.IsNullOrEmpty(requestVersion))
{
throw new Exception($"'{ApiHeaders.XExperienceApiVersion}' header or it's null or empty.");
}
try
{
ApiVersion version = requestVersion;
}
catch (Exception)
{
throw new Exception($"'{ApiHeaders.XExperienceApiVersion}' header is '{requestVersion}' which is not supported.");
}
}
catch (Exception ex)
{
var response = context.Request.CreateResponse(System.Net.HttpStatusCode.BadRequest, ex.Message + " Supported Versions are: " + string.Join(", ", supported.Select(x => x.Key)));
context.Response = response;
context.Response.Headers.Add(ApiHeaders.XExperienceApiVersion, ApiVersion.GetLatest().ToString());
}
}
private static bool ValidateParameters(PagedStatementsQuery parameters)
{
var otherParameters = parameters.ToParameterMap(ApiVersion.GetLatest());
otherParameters.Remove("attachments");
otherParameters.Remove("format");
return(otherParameters.Count == 0);
}
/// <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 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 Group(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
protected InteractionActivityDefinitionBase(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public StatementCollection(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public async Task ExecuteResultAsync(ActionContext context)
{
string strJson = _statement.ToJson(_format);
HttpContent httpContent = new StringContent(strJson, Encoding.UTF8, MediaTypes.Application.Json);
var attachmentsWithPayload = _statement.Attachments.Where(a => a.Payload != null);
if (_statement.Attachments.Any(x => x.Payload != null))
{
string boundary = Guid.NewGuid().ToString();
httpContent = new MultipartContent("mixed", boundary)
{
httpContent
};
foreach (var attachment in _statement.Attachments)
{
if (attachment.Payload != null)
{
((MultipartContent)httpContent).AddAttachment(attachment);
}
}
}
foreach (var header in httpContent.Headers)
{
context.HttpContext.Response.Headers.Add(
header.Key,
new StringValues(header.Value.ToArray())
);
}
context.HttpContext.Response.Headers.Add(ApiHeaders.XExperienceApiVersion, ApiVersion.GetLatest().ToString());
await httpContent.CopyToAsync(context.HttpContext.Response.Body);
httpContent.Dispose();
}
public InteractionComponent(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public StatementsResult(JsonString jsonString)
: this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public Statement(JToken jtoken) : this(jtoken, ApiVersion.GetLatest())
{
}
public Context(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
private ActivityDefinition GetActivityInteraction(int interactionIndex)
{
ActivityDefinition interactionDef = null;
using (SqlConnection connection = new SqlConnection(DbUtils.GetConnectionString()))
{
SqlDataReader reader = null;
SqlCommand command = new SqlCommand(GetActivityInteractionQuery, connection);
command.Parameters.AddWithValue("@id", interactionIndex);
try
{
connection.Open();
reader = command.ExecuteReader();
if (reader.Read())
{
InteractionType type = reader.GetString(1);
interactionDef = type.CreateInstance(new JObject(), ApiVersion.GetLatest());
if (!reader.IsDBNull(2))
{
JsonString json = reader.GetString(2);
var sList = new List <string>();
var crp = json.ToJArray();
foreach (var jstring in crp)
{
sList.Add(jstring.Value <string>());
}
(interactionDef as InteractionActivityDefinitionBase).CorrectResponsesPattern = sList.ToArray();
}
if (!reader.IsDBNull(3))
{
Choice cho = interactionDef as Choice;
Sequencing seq = interactionDef as Sequencing;
if (cho != null)
{
cho.Choices = new InteractionComponentCollection(reader.GetString(3));
}
else if (seq != null)
{
seq.Choices = new InteractionComponentCollection(reader.GetString(3));
}
}
if (!reader.IsDBNull(4))
{
Likert def = interactionDef as Likert;
if (def != null)
{
def.Scale = new InteractionComponentCollection(reader.GetString(4));
}
}
if (!reader.IsDBNull(5))
{
Matching match = interactionDef as Matching;
if (match != null)
{
match.Source = new InteractionComponentCollection(reader.GetString(5));
}
}
if (!reader.IsDBNull(6))
{
Matching match = interactionDef as Matching;
if (match != null)
{
match.Target = new InteractionComponentCollection(reader.GetString(6));
}
}
if (!reader.IsDBNull(7))
{
Performance perf = interactionDef as Performance;
if (perf != null)
{
perf.Steps = new InteractionComponentCollection(reader.GetString(7));
}
}
}
}
catch (Exception ex)
{
return(null);
}
finally
{
if (reader != null && !reader.IsClosed)
{
reader.Close();
}
}
}
return(interactionDef);
}
public Verb(JToken verb) : this(verb, ApiVersion.GetLatest())
{
}
/// <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);
}
/// <exception cref="LanguageTagException" />
public LanguageMap(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next)
{
var supported = ApiVersion.GetSupported();
try
{
if (!context.HttpContext.Request.Headers.ContainsKey(ApiHeaders.XExperienceApiVersion))
{
throw new Exception($"Missing '{ApiHeaders.XExperienceApiVersion}' header.");
}
string requestVersion = context.HttpContext.Request.Headers[ApiHeaders.XExperienceApiVersion];
if (string.IsNullOrEmpty(requestVersion))
{
throw new Exception($"'{ApiHeaders.XExperienceApiVersion}' header or it's null or empty.");
}
try
{
ApiVersion version = requestVersion;
}
catch (Exception)
{
throw new Exception($"'{ApiHeaders.XExperienceApiVersion}' header is '{requestVersion}' which is not supported.");
}
await next();
}
catch (Exception ex)
{
context.HttpContext.Response.Headers.Add(ApiHeaders.XExperienceApiVersion, ApiVersion.GetLatest().ToString());
context.Result = new BadRequestObjectResult(ex.Message + " Supported Versions are: " + string.Join(", ", supported.Select(x => x.Key)));
}
}
/// <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);
}
public AttachmentCollection(JToken jarr) : this(jarr, ApiVersion.GetLatest())
{
}
public Attachment(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public StatementRef(JToken jobj) : this(jobj, ApiVersion.GetLatest())
{
}
public ApiJsonSerializer()
: this(ApiVersion.GetLatest())
{
}
public ActivityCollection(JsonString jsonString) : this(jsonString.ToJToken(), ApiVersion.GetLatest())
{
}
public ExtensionsDictionary(JToken jobj) : this(jobj, ApiVersion.GetLatest())
{
}
