private void CreateDatabaseRequest(BasicNodeViewModel model, DatabaseRequestType type)
{
// Check the relationships
foreach (RelationshipViewModel rel in model.Relationships)
{
// If the referenced node does not have an id,
if (!rel.TargetId.HasValue)
{
// Give the referenced node an id
rel.TargetId = Guid.NewGuid();
// Set the value of IsNewAddition to true
rel.IsNewAddition = true;
}
}
using (ApplicationDbContext context = ApplicationDbContext.Create())
{
// Get the user that submitted the request
ApplicationUser submitter = context.Users.Single(x => x.UserName == User.Identity.Name);
// Create the request
DatabaseRequest request = new DatabaseRequest
{
RequestType = type,
Id = Guid.NewGuid(),
SubmissionDate = DateTime.Now,
Submitter = submitter,
NodeDataType = model.ContentType,
NodeData = model.SerializeToContentType(),
};
// Add the request to the database
context.Requests.Add(request);
context.SaveChanges();
}
}
public bool CheckRequestsAndCommitChanges(BasicNodeViewModel fromForm, DatabaseRequest fromDatabase)
{
bool result = true;
//try
//{
DatabaseDriver systemDriver = new DatabaseDriver();
if (fromDatabase.RequestType == DatabaseRequestType.Create)
{
systemDriver.AddNode(fromForm.ToModel());
}
else if (fromDatabase.RequestType == DatabaseRequestType.Update)
{
systemDriver.UpdateNode(fromForm.ToModel());
}
else if (fromDatabase.RequestType == DatabaseRequestType.Delete)
{
systemDriver.DeleteNode(fromForm.Id);
}
//}
//catch
//{
// result = false;
//}
return(result);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException("Binding context is null", "bindingContext");
}
HttpRequestBase formRequest = controllerContext.HttpContext.Request;
RequestReviewViewModel result = new RequestReviewViewModel();
Guid requestId;
DatabaseRequestType requestType;
NodeContentType nodeDataType;
bool approved;
BasicNodeViewModel nodeViewModel = null;
if (!Guid.TryParse(formRequest.Form["RequestId"], out requestId))
{
bindingContext.ModelState.AddModelError("RequestId", "Invalid request id");
}
if (!Enum.TryParse <DatabaseRequestType>(formRequest.Form["RequestType"], out requestType))
{
bindingContext.ModelState.AddModelError("RequestType", "Invalid request type");
}
if (!Enum.TryParse <NodeContentType>(formRequest.Form["NodeDataType"], out nodeDataType))
{
bindingContext.ModelState.AddModelError("NodeDataType", "Invalid node data type");
}
// I don't really care about the full data for the deletion requests
if (requestType != DatabaseRequestType.Delete)
{
nodeViewModel = (new NodeModelBinder()).BindModel(controllerContext, bindingContext) as BasicNodeViewModel;
}
else
{
nodeViewModel = new BasicNodeViewModel {
Id = Guid.Parse(formRequest.Form["Id"]), ContentType = nodeDataType
};
}
if (!bool.TryParse(formRequest.Form["Approved"], out approved))
{
bindingContext.ModelState.AddModelError("Approved", "Invalid approval state");
}
if (bindingContext.ModelState.IsValid)
{
result = new RequestReviewViewModel
{
RequestId = requestId,
RequestType = requestType,
NodeDataType = nodeDataType,
NodeData = nodeViewModel,
Notes = formRequest.Form["Notes"],
Approved = approved
};
}
return(result);
}
public ActionResult FlagDeletion(Guid id)
{
string message = "An error occurred. The node was not flagged";
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
BasicNodeModel toDelete = null;
using (NeoDriver driver = new NeoDriver())
{
toDelete = driver.GetNode(id);
}
// If the node with the given id is not null,
if (toDelete != null)
{
DatabaseRequest request = new DatabaseRequest
{
Id = Guid.NewGuid(),
RequestType = DatabaseRequestType.Delete,
SubmissionDate = DateTime.Now,
NodeDataType = toDelete.ContentType,
NodeData = JsonConvert.SerializeObject(BasicNodeViewModel.FromModel(toDelete)),
Approved = false,
ApprovalDate = null,
Notes = null,
Reviewed = false,
ReviewedDate = null,
Reviewer = null,
ReviewerRefId = null
};
// Add a deletion request,
using (ApplicationDbContext context = ApplicationDbContext.Create())
{
request.Submitter = context.Users.Single(u => u.UserName == User.Identity.Name);
context.Requests.Add(request);
context.SaveChanges();
}
message = "Node flagged for deletion";
Response.StatusCode = (int)HttpStatusCode.Accepted;
}
else
{
message = "Could not find the specified node.";
Response.StatusCode = (int)HttpStatusCode.NotFound;
}
return(Json(new { message = message }));
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException("Binding context is null", "bindingContext");
}
HttpRequestBase request = controllerContext.HttpContext.Request;
BasicNodeViewModel result = null;
NodeContentType contentType = (NodeContentType)Enum.Parse(typeof(NodeContentType), request.Form["ContentType"]);
DateTime? releaseDate = request.Form["ReleaseDate"] != null?ParseDateTime(request.Form["ReleaseDate"]) : null;
DateTime?deathDate = contentType == NodeContentType.Media ? null : request.Form["DeathDate"] != null?ParseDateTime(request.Form["DeathDate"]) : null;
if (contentType == NodeContentType.Company)
{
result = new CompanyNodeViewModel();
}
else if (contentType == NodeContentType.Media)
{
result = new MediaNodeViewModel
{
Genres = ParseFromJson <IEnumerable <string> >(request.Form["Genres"]),
MediaType = (NodeMediaType)Enum.Parse(typeof(NodeMediaType), request.Form["MediaType"]),
FranchiseName = request.Form["FranchiseName"].Trim()
};
}
else if (contentType == NodeContentType.Person)
{
result = new PersonNodeViewModel
{
GivenName = request.Form["GivenName"].Trim(),
FamilyName = request.Form["FamilyName"].Trim(),
Status = (PersonStatus)Enum.Parse(typeof(PersonStatus), request.Form["Status"])
};
}
result.Id = Guid.Parse(request.Form["Id"]);
result.ContentType = contentType;
result.CommonName = contentType == NodeContentType.Person ? $"{((PersonNodeViewModel)result).GivenName} {((PersonNodeViewModel)result).FamilyName}" : request.Form["CommonName"].Trim();
result.OtherNames = ParseFromJson <IEnumerable <string> >(request.Form["OtherNames"]);
result.ReleaseDate = releaseDate;
result.DeathDate = deathDate;
result.Relationships = ParseFromJson <IEnumerable <RelationshipViewModel> >(request.Form["Relationships"]);
// Validate the object
Validate(result, bindingContext);
return(result);
}
/// <summary>
/// Run the validator to validate the object and add validation errors to the model state.
/// </summary>
/// <param name="boundObject">The object being bound</param>
/// <param name="context">The model binding context</param>
private void Validate(BasicNodeViewModel boundObject, ModelBindingContext context)
{
List <ValidationResult> errors = new List <ValidationResult>();
// If the model is not valid
if (!Validator.TryValidateObject(boundObject, new ValidationContext(boundObject, null, null), errors, true))
{
// Add the model errors to the ModelState
foreach (ValidationResult err in errors)
{
foreach (string propertyKey in err.MemberNames)
{
context.ModelState.AddModelError(propertyKey, err.ErrorMessage);
}
}
}
}
/// <summary>
/// Parses the node data string
/// </summary>
/// <returns>The </returns>
public BasicNodeViewModel ParseModel()
{
BasicNodeViewModel viewModel = null;
if (NodeDataType == NodeContentType.Company)
{
viewModel = JsonConvert.DeserializeObject <CompanyNodeViewModel>(NodeData) as CompanyNodeViewModel;
}
else if (NodeDataType == NodeContentType.Media)
{
viewModel = JsonConvert.DeserializeObject <MediaNodeViewModel>(NodeData) as MediaNodeViewModel;
}
else if (NodeDataType == NodeContentType.Person)
{
viewModel = JsonConvert.DeserializeObject <PersonNodeViewModel>(NodeData) as PersonNodeViewModel;
}
return(viewModel);
}
// GET: Edit/Index/
public ActionResult Index(string id)
{
ActionResult result = View("Error");
if (!string.IsNullOrWhiteSpace(id))
{
// Try to parse the Guid string
Guid parsedId;
if (Guid.TryParse(id, out parsedId))
{
// The string was parsed, find the node
// We have been given an id of a node to edit
ViewBag.Title = "Edit Node Data";
BasicNodeViewModel viewModel = null;
// Get the node to edit
using (NeoDriver driver = new NeoDriver())
{
BasicNodeModel model = driver.GetNodeAndRelationships(parsedId);
viewModel = BasicNodeViewModel.FromModel(model);
}
// Return a view
if (viewModel != null)
{
result = View(model: viewModel);
}
}
else
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
Response.StatusDescription = $"Invalid id value: {id}";
}
}
else
{
// We are creating a new node
ViewBag.Title = "Create New Node";
result = View(model: new BasicNodeViewModel {
Id = Guid.NewGuid(), ContentType = 0
});
}
return(result);
}
private ActionResult CheckModelAndMakeRequest(BasicNodeViewModel model)
{
ActionResult result = View("Index", model);
// If the model state is valid,
if (ModelState.IsValid)
{
DatabaseRequestType requestType = 0;
using (NeoDriver driver = new NeoDriver())
{
// TODO: This will no longer work to check if this is an update or creation request
requestType = driver.GetNode(model.Id) != null ? DatabaseRequestType.Update : DatabaseRequestType.Create;
}
// Create the database request
CreateDatabaseRequest(model, requestType);
// Redirect to the accepted page
result = RedirectToAction("Accepted", "Edit");
}
return(result);
}
public ActionResult Index(BasicNodeViewModel model)
{
return(CheckModelAndMakeRequest(model));
}
