public WriteResult CreateObjectInDatastore(EmergencyObject data, string store)
{
try
{
var bson = data.ToBsonDocument();
db.GetCollection <BsonDocument>(store).InsertOne(bson);
return(WriteResult.OK);
}
catch (TimeoutException timeoutEx)
{
return(WriteResult.ServerError);
}
catch (MongoWriteException we)
{
if (we.WriteError.Code == 11000)
{
/* Duplicated */
return(WriteResult.Duplicated);
}
else
{
return(WriteResult.ServerError);
}
}
}
public CreateObjectResult CreateObjectInDatastore(EmergencyObject data)
{
CreateObjectResult result = new CreateObjectResult();
result.writeResult = db.CreateObjectInDatastore(data, "objects");
result.createdObject = data;
return(result);
}
public static void DeserializeEmergencyObjectBody(EmergencyObject obj)
{
if (obj.Data is JObject)
{
if (obj.Header.DataType.HasValue)
{
var typ = registeredDataTypes[obj.Header.DataType.Value];
obj.Data = ((JObject)obj.Data).ToObject(typ);
}
}
}
public async Task <ActionResult <object> > UpdateObject(Guid uid, [FromBody] EmergencyObject data)
{
var result = db.GetObjectFromDatastore(uid);
var identity = GetCurrentIdentity();
if (result.data == null)
{
return(NotFound());
}
var res = result.data as EmergencyObject;
if (!CanWrite(res, identity, null))
{
return(Forbid());
}
var dataType = EmergencyModelInformation.RegisteredDataTypes[res.header.dataType].Typ;
var body = ((JObject)data.data).ToObject(dataType);
try
{
TryValidateModel(body);
}
catch (Exception ex)
{
var problems = new ValidationProblemDetails(ModelState);
return(BadRequest(problems));
}
res.data = body;
res.header.documentVersion++;
res.header.lastUpdated = DateTime.UtcNow;
res.header.lastUpdatedBy = identity.uid;
if (ModelState.IsValid)
{
db.UpdateObjectInDatastore(res);
changeTracker.ObjectChanged(res.uid.Value, Websocket.Message.MessageSentTrigger.Updated, res, null);
return(Ok(res));
}
else
{
var problems = new ValidationProblemDetails(ModelState);
return(BadRequest(problems));
}
}
public ActionResult <EmergencyObject> UpdateObjectInDatastore(EmergencyObject data)
{
var res = db.UpdateObjectInDatastore(data, "objects");
if (res == WriteResult.OK)
{
return(new CreatedResult("/object/" + data.uid.Value.ToString(), data));
}
else if (res == WriteResult.Duplicated)
{
return(new ConflictResult());
}
else
{
return(new StatusCodeResult(500));
}
}
/// <summary>
/// Checks if the user can change Permissions on the document
/// </summary>
/// <param name="obj"></param>
/// <param name="id"></param>
/// <returns></returns>
private bool CanGrant(EmergencyObject obj, EndpointIdentity id)
{
bool isOwner = (obj.header.createdBy == id.uid);
if (isOwner)
{
return(true);
}
/* Berechtigung über AccessLevel prüfen */
if (access.CheckAccessForPath("*", id.accessIdentity, obj.header.Access, AccessLevelEnum.Grant) >= AccessLevelEnum.Grant)
{
return(true);
}
return(false);
}
public List <string> GetAccessPaths(AccessLevelEnum requiredAccessLevel, EmergencyObject obj, EndpointIdentity id)
{
List <string> res;
bool isOwner = (obj.header.createdBy == id.uid);
if (isOwner)
{
res = new List <string>()
{
"*"
};
return(res);
}
res = access.GetPathsByAccessLevel(requiredAccessLevel, id.accessIdentity, obj.header.Access);
return(res);
}
/// <summary>
/// Checks if the user can read the Subpath on the given Document
/// </summary>
/// <param name="obj"></param>
/// <param name="id"></param>
/// <param name="subPath"></param>
/// <returns></returns>
private bool CanRead(EmergencyObject obj, EndpointIdentity id, string subPath)
{
bool isOwner = (obj.header.createdBy == id.uid);
/* Nutzer ist Besitzer des Objekts */
if (isOwner)
{
return(true);
}
/* Berechtigung über AccessLevel prüfen */
if (access.CheckAccessForPath(subPath, id.accessIdentity, obj.header.Access, AccessLevelEnum.Read) >= AccessLevelEnum.Read)
{
return(true);
}
return(false);
}
public void ObjectChanged(Guid uid, MessageSentTrigger trigger, EmergencyObject edxo, object subData, string subPath = null)
{
var eventMsg = new EmergencyObjectMessage()
{
uid = uid,
header = edxo.header,
messageTrigger = trigger,
};
if (subPath != null)
{
eventMsg.isParted = true;
eventMsg.partPath = subPath;
eventMsg.data = subData;
}
else
{
eventMsg.isParted = false;
eventMsg.data = edxo.data;
}
ws.PropagateChange(eventMsg);
}
public ActionResult <EmergencyObject> CreateObject([FromBody] EmergencyObject data)
{
var identity = GetCurrentIdentity();
if (data == null)
{
return(new NoContentResult());
}
if (!data.uid.HasValue)
{
data.uid = Guid.NewGuid();
}
if (data.header == null)
{
data.header = new EmergencyObjectHeader();
}
data.header.created = DateTime.UtcNow;
data.header.createdBy = identity.uid;
data.header.lastUpdated = DateTime.UtcNow;
data.header.documentVersion = 1;
/* Minimum TTL is 120 minutes */
if (data.header.timeToLive < 120 && data.header.timeToLive != 0)
{
data.header.timeToLive = 120;
}
/* Maximum TTL on this Server = 30 days */
if (data.header.timeToLive > 60 * 24 * 30)
{
data.header.timeToLive = 60 * 24 * 30;
}
if (!EmergencyModelInformation.RegisteredDataTypes.ContainsKey(data.header.dataType))
{
var details = new ProblemDetails();
details.Status = 400;
details.Title = "Specified Data Type \"" + data.header.dataType + "\" is not known!";
return(new BadRequestObjectResult(details));
}
var dataType = EmergencyModelInformation.RegisteredDataTypes[data.header.dataType];
/* Check TTL for datatype */
if (dataType.MaximumTimeToLive != 0)
{
if (data.header.timeToLive > dataType.MaximumTimeToLive || data.header.timeToLive == 0)
{
data.header.timeToLive = dataType.MaximumTimeToLive;
}
}
var body = ((JObject)data.data).ToObject(dataType.Typ);
var valid = ModelState.IsValid;
TryValidateModel(body);
if (ModelState.IsValid)
{
data.data = body;
var res = db.CreateObjectInDatastore(data);
if (res.writeResult == WriteResult.OK)
{
changeTracker.ObjectChanged(data.uid.Value, Websocket.Message.MessageSentTrigger.Created, data, null);
return(new CreatedResult("/object/" + data.uid.Value.ToString(), data));
}
else if (res.writeResult == WriteResult.Duplicated)
{
return(new ConflictResult());
}
else
{
return(new StatusCodeResult(500));
}
}
else
{
var problems = new ValidationProblemDetails(ModelState);
return(BadRequest(problems));
}
}
private List <string> GetAccessablePaths(AccessLevelEnum acl, EmergencyObject obj, EndpointIdentity id)
{
return(access.GetPathsByAccessLevel(acl, id.accessIdentity, obj.header.Access));
}
