private async Task <dynamic> Login(dynamic paramters, CancellationToken cancel)
{
User user = await userService.Login(Context.Request.Form["username"], Context.Request.Form["password"]);
object returnObject = user != null ? new UserViewModel(user) : null;
var statusCode = HttpStatusCode.OK;
if (returnObject == null)
{
statusCode = HttpStatusCode.Forbidden;
returnObject = new Error("The provided username or password is wrong");
}
else
{
Context.Request.Session["user"] = user.UserName;
Context.CurrentUser = new NancyUser(user);
}
return(Negotiate.WithModel(returnObject)
.WithStatusCode(statusCode));
}
public ApiControleAcesso() : base("/api/controle-acesso/")
{
Post("autenticar", _ =>
{
var entidade = this.Bind <Autenticacao>();
if (string.IsNullOrWhiteSpace(entidade.Usuario) ||
string.IsNullOrWhiteSpace(entidade.Senha))
{
throw new Exception("Usuário e/ou Senha não informado.");
}
var info = new TokenInfo()
{
Usuario = entidade.Usuario,
DataAcesso = DateTime.Now
};
return(Negotiate.WithStatusCode(HttpStatusCode.OK)
.WithModel(this.JsonResponse(new { apiKey = ControleAcessoJwt.GerarToken(info) })));
});
}
private void InstantiateMachine()
{
Post("{SchematicName}/instantiate/", async(parameters, ct) =>
{
var stateEngine = StateEngineFactory
.GetStateEngine(Context.CurrentUser?.GetApiKey());
var metadata = this.Bind <IDictionary <string, string> >();
string schematicName = parameters.SchematicName;
var machineId = await stateEngine
.InstantiateMachine(schematicName, metadata, ct);
return(Negotiate
.WithModel(new MachineInstanceResponse
{
MachineId = machineId
})
.WithAllowedMediaRange("application/json"));
});
}
public IndexModule()
{
Post["/order"] = _ =>
{
var order = this.Bind <Order>();
var bill = HandleOrder(order);
if (bill == null)
{
return(new {});
}
return(bill);
};
Post["/feedback"] = _ =>
{
var feedback = this.Bind <Feedback>();
HandleFeedback(feedback);
return(Negotiate.WithStatusCode(HttpStatusCode.OK));
};
}
public AgentHistoryModule(IAgentDataService agentDataService)
{
Post["/api/agentHistory"] = p =>
{
AgentExecution agentExecution = this.Bind <AgentExecution>();
if (agentExecution == null)
{
return(HttpStatusCode.BadRequest);
}
agentDataService.GetInsertedData(agentExecution);
return(HttpStatusCode.OK);
};
Get["/api/agentHistory"] = p =>
{
var x = agentDataService.GetExecutedListAgentDetails();
return(Negotiate
.WithContentType("aplication/json")
.WithModel(x));
};
}
public RootModule()
{
Get["/"] = parameters =>
{
var model = new RootUrls
{
AuditUrl = BaseUrl + "/audit/{?page,per_page,direction,sort}",
EndpointsAuditUrl = BaseUrl + "/endpoints/{name}/audit/{?page,per_page,direction,sort}",
EndpointsUrl = BaseUrl + "/endpoints",
ErrorsUrl = BaseUrl + "/errors/{?page,per_page,direction,sort}",
EndpointsErrorUrl = BaseUrl + "/endpoints/{name}/errors/{?page,per_page,direction,sort}",
MessageSearchUrl =
BaseUrl + "/messages/search/{keyword}/{?page,per_page,direction,sort}",
EndpointsMessageSearchUrl =
BaseUrl +
"/endpoints/{name}/messages/search/{keyword}/{?page,per_page,direction,sort}",
EndpointsMessagesUrl =
BaseUrl + "/endpoints/{name}/messages/{?page,per_page,direction,sort}",
Name = SettingsReader <string> .Read("Name", "Particular Management"),
Description = SettingsReader <string> .Read("Description", "Description for Particular Management"),
};
return(Negotiate
//.WithMediaRangeModel(MediaRange.FromString(@"application/vnd.particular-v1"), new RootUrls{
// AuditUrl = baseUrl + "/audit/{?page,per_page,direction,sort}",
// EndpointsAuditUrl = baseUrl + "/endpoints/{name}/audit/{?page,per_page,direction,sort}",
// })
//.WithMediaRangeModel(MediaRange.FromString(@"application/vnd.particular-v2"), new RootUrls
// {
// AuditUrl = baseUrl + "/audit/{?page,per_page,direction,sort}",
// EndpointsAuditUrl = baseUrl + "/endpoints/{name}/audit/{?page,per_page,direction,sort}",
// })
.WithModel(model)
.WithHeader("ETag", CurrentEtag)
.WithHeader("Last-Modified", CurrentLastModified)
.WithHeader("Cache-Control", "private, max-age=0, must-revalidate"));
};
}
async Task <dynamic> GetGroupErrors(string groupId)
{
using (var session = Store.OpenAsyncSession())
{
var results = await session.Advanced
.AsyncDocumentQuery <FailureGroupMessageView, FailedMessages_ByGroup>()
.Statistics(out var stats)
.WhereEquals(view => view.FailureGroupId, groupId)
.FilterByStatusWhere(Request)
.FilterByLastModifiedRange(Request)
.Sort(Request)
.Paging(Request)
.SetResultTransformer(FailedMessageViewTransformer.Name)
.SelectFields <FailedMessageView>()
.ToListAsync()
.ConfigureAwait(false);
return(Negotiate.WithModel(results)
.WithPagingLinksAndTotalCount(stats, Request)
.WithEtag(stats));
}
}
public StoreModule(IBrightstarService brightstarService, AbstractStorePermissionsProvider storePermissionsProvider)
{
this.RequiresBrightstarStorePermission(storePermissionsProvider, get: StorePermissions.Read, delete: StorePermissions.Admin);
Get["/{storeName}"] = parameters =>
{
var storeName = parameters["storeName"];
ViewBag.Title = storeName;
if (!brightstarService.DoesStoreExist(storeName))
{
return(HttpStatusCode.NotFound);
}
if (Request.Method.ToUpperInvariant() == "HEAD")
{
IEnumerable <ICommitPointInfo> commitPoints = brightstarService.GetCommitPoints(storeName, 0, 1);
var commit = commitPoints.First();
return
(Negotiate.WithHeader("Last-Modified", commit.CommitTime.ToUniversalTime().ToString("r"))
.WithStatusCode(HttpStatusCode.OK)
.WithModel(new StoreResponseModel(parameters["storeName"])));
}
return(new StoreResponseModel(parameters["storeName"]));
};
Delete["/{storeName}"] = parameters =>
{
var storeName = parameters["storeName"];
ViewBag.Title = "Deleted - " + storeName;
if (brightstarService.DoesStoreExist(storeName))
{
brightstarService.DeleteStore(storeName);
}
return(Negotiate.WithMediaRangeModel(new MediaRange("text/html"),
new StoreDeletedModel {
StoreName = storeName
}));
};
}
public VersionsModule(INeo4jVersionRepository versionRepository) : base("/versions")
{
// Get all versions
Get("/", _ =>
{
var viewModel = new VersionsViewModel
{
Versions = versionRepository.GetVersions()
};
return(Negotiate
.WithModel(viewModel)
.WithView("Versions"));
});
// Get single version by number
Get("/{VersionNumber}", ctx =>
{
string versionNumber = ctx.VersionNumber.ToString();
return(versionRepository.GetVersions().Single(v => v.VersionNumber == versionNumber));
});
}
public dynamic PostUser(dynamic arg)
{
User model = null;
try
{
model = this.Bind <User>();
}
catch
{
return(Negotiate.WithModel("Incorrect object structure.").WithStatusCode(HttpStatusCode.BadRequest));
}
if (this.dao.Register(model))
{
User user = this.dao.GetUserByEmail(model.Email);
return(user);
}
else
{
return(HttpStatusCode.BadRequest);
}
}
private void PreviewDiagram()
{
Post("/preview/diagram", (parameters) =>
{
var stateEngine = StateEngineFactory
.GetStateEngine(Context.CurrentUser?.GetApiKey());
var stateMachineConfiguration = this.Bind <Schematic>();
var diagram = stateEngine
.PreviewDiagram(stateMachineConfiguration);
if (diagram == null)
{
throw new Exception("Unable to read schematic.");
}
return(Negotiate
.WithMediaRangeResponse("text/plain", Response.AsText(diagram, "text/plain"))
.WithAllowedMediaRange("text/plain"));
});
}
public ApiModule(IFileUploadHandler fileUploadHandler, ILayoutHandler layoutHandler) : base("/api")
{
_fileUploadHandler = fileUploadHandler;
_layoutHandler = layoutHandler;
Post("/upload", async(args, ctx) =>
{
var request = this.Bind <UploadRequest>();
var uploadResult = await _fileUploadHandler.HandleUpload(request.File.Value);
var response = new ApiResponse <FileUploadResult>(ApiResponse <FileUploadResult> .OK, uploadResult);
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response));
});
Get("/layout", async(args, ctx) =>
{
var request = Request.Query["id"].ToString();
var result = await _layoutHandler.handleLayout(request);
var code = result == null ? ApiResponse <LayoutResult> .ERR : ApiResponse <LayoutResult> .OK;
var status = result == null ? HttpStatusCode.BadRequest : HttpStatusCode.OK;
var response = new ApiResponse <LayoutResult>(code, result);
return(Negotiate
.WithStatusCode(status)
.WithModel(response));
});
Post("/update", async(args, ctx) =>
{
var request = this.Bind <UpdateRequest>();
var result = await _layoutHandler.updateLayout(request);
var response = new ApiResponse <LayoutResult>(ApiResponse <LayoutResult> .OK, result);
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(response));
});
}
public GetErrorById()
{
Get["/errors/{id}", true] = async(parameters, token) =>
{
Guid failedMessageId = parameters.id;
using (var session = Store.OpenAsyncSession())
{
var message = await session.LoadAsync <FailedMessage>(failedMessageId).ConfigureAwait(false);
if (message == null)
{
return(HttpStatusCode.NotFound);
}
return(Negotiate.WithModel(message));
}
};
Get["/errors/last/{id}", true] = async(parameters, token) =>
{
Guid failedMessageId = parameters.id;
using (var session = Store.OpenAsyncSession())
{
var message = await session.LoadAsync <FailedMessage>(failedMessageId).ConfigureAwait(false);
if (message == null)
{
return(HttpStatusCode.NotFound);
}
var result = Map(message, session);
return(Negotiate.WithModel(result));
}
};
}
public AdminModule(GetSessions getAllSessions, GetSession getSessionDetail, SessionProvider provider)
: base("/admin")
{
this.RequiresAuthentication();
Get["/sessions"] = _ => Negotiate.WithModel(new AdminSessionsViewModel(getAllSessions()));
Get["/sessions/{id}"] = p => Negotiate.WithModel(getSessionDetail((string)p.Id));
Post["/sessions/{id}/bulk-feedback", runAsync : true] = async(p, token) =>
{
int sessionId = p.id;
Level rating = Enum.Parse(typeof(Level), Request.Form.rating);
await provider.AddBulkFeedback(sessionId, rating, Request.Form.count);
return(Response.AsRedirect("~/admin/sessions/" + sessionId));
};
Post["/sessions/{id}/feedback", runAsync : true] = async(p, token) =>
{
int sessionId = p.id;
Level rating = Enum.Parse(typeof(Level), Request.Form.rating);
string comments = Request.Form.comments;
if (String.IsNullOrWhiteSpace(comments))
{
throw new InvalidOperationException("Need comments.");
}
provider.AddFeedback(new Feedback
{
Comments = comments,
Rating = (int)rating,
SessionId = sessionId
});
return(Response.AsRedirect("~/admin/sessions/" + sessionId));
};
}
public GetErrorById()
{
Get["/errors/{id}"] = parameters =>
{
Guid failedMessageId = parameters.id;
using (var session = Store.OpenSession())
{
var message = session.Load <FailedMessage>(failedMessageId);
if (message == null)
{
return(HttpStatusCode.NotFound);
}
return(Negotiate.WithModel(message));
}
};
Get["/errors/last/{id}"] = parameters =>
{
Guid failedMessageId = parameters.id;
using (var session = Store.OpenSession())
{
var message = session.Load <FailedMessage>(failedMessageId);
if (message == null)
{
return(HttpStatusCode.NotFound);
}
var result = Map(message, session);
return(Negotiate.WithModel(result));
}
};
}
private void IsInState() =>
Get("/{MachineId}/isinstate/{StateName}", async(parameters, ct) =>
{
var stateEngine = StateEngineFactory
.GetStateEngine(Context.CurrentUser?.GetApiKey());
string machineId = parameters.MachineId;
string isInStateName = parameters.StateName;
var machine = await stateEngine
.GetMachine(machineId, ct);
var isInState = await machine.IsInStateAsync(
new State(isInStateName), ct);
return(Negotiate
.WithModel(new IsInStateResponse
{
QueriedStateName = isInStateName,
IsInState = isInState
})
.WithAllowedMediaRange("application/json"));
});
public ApiModule()
{
Get["/heartbeats/stats"] = _ => Negotiate.WithModel(Monitoring.GetStats());
Get["/endpoints"] = _ => Negotiate.WithModel(Monitoring.GetEndpoints());
Patch["/endpoints/{id}"] = parameters =>
{
var data = this.Bind <EndpointUpdateModel>();
var endpointId = (Guid)parameters.id;
if (data.MonitorHeartbeat)
{
Monitoring.EnableMonitoring(endpointId);
}
else
{
Monitoring.DisableMonitoring(endpointId);
}
return(HttpStatusCode.Accepted);
};
}
public BlogPostModule(PostProvider provider)
: base("/Posts")
{
Post["/{start:int}/{finish:int}"] = args =>
{
IEnumerable <Post> posts = provider.GetPosts(args.start, args.finish);
return(Negotiate.WithModel(posts).WithView("BlogPosts"));
};
Post["/{PostName}"] = args =>
{
Post model = provider.GetPost(args.PostName);
return(Negotiate
.WithModel(model)
.WithView("FullPost")
.WithHeader("blog-title", model.MetaData.Title));
};
Get["/{path}"] = args =>
{
return(View["Views/Index.cshtml", (string)args.path]);
};
}
public HomeModule(UserSessions sessions)
{
Get["/"] = x =>
{
return(View["Index"]);
};
Get["/Login"] = _ => View["Login", new LoginModel()];
Post["/Login"] = data =>
{
var login = this.BindAndValidate <LoginModel>();
if (!this.ModelValidationResult.IsValid)
{
return(Negotiate
.WithModel(this.ModelValidationResult.FormattedErrors)
.WithStatusCode(HttpStatusCode.BadRequest));
}
var user = sessions.Create(login.Username);
return(Response.AsRedirect("/?sid=" + user.Sid));
};
}
public MazePageModule(IMazePageClient mazePageClient, IMazePageStore store) : base("/shows")
{
Get(
"/",
async _ =>
{
IEnumerable <Show> result = await store.LoadShowsByPageIdAsync(Request.Query.page);
if (!result.Any())
{
result = await mazePageClient.FetchShowsAsync(Request.Query.page).ConfigureAwait(false);
await store.SaveMazePageAsync(Request.Query.page, result).ConfigureAwait(false);
}
var to = 0;
if (int.TryParse(Request.Query["from"], out int from) && int.TryParse(Request.Query["to"], out to))
{
result = result.Skip(from).Take(to - from);
}
return(Negotiate.WithModel(result).WithHeader("cache-control", "max-age:86400"));
});
}
dynamic GetGroupErrors(string groupId)
{
using (var session = Store.OpenSession())
{
RavenQueryStatistics stats;
var results = session.Advanced
.LuceneQuery <FailureGroupMessageView, FailedMessages_ByGroup>()
.Statistics(out stats)
.WhereEquals(view => view.FailureGroupId, groupId)
.FilterByStatusWhere(Request)
.FilterByLastModifiedRange(Request)
.Sort(Request)
.Paging(Request)
.SetResultTransformer(new FailedMessageViewTransformer().TransformerName)
.SelectFields <FailedMessageView>()
.ToArray();
return(Negotiate.WithModel(results)
.WithPagingLinksAndTotalCount(stats, Request)
.WithEtagAndLastModified(stats));
}
}
public Object GetHandler(int orderId)
{
var order = orderRepository.GetById(orderId);
if (order == null)
{
return((Response)HttpStatusCode.NotFound);
}
if (order.Status == OrderStatus.Canceled)
{
return(Response.MovedTo(linker.BuildUriString(Context, "ReadCancelledOrder", new { orderId })));
}
if (Request.IsNotModified(order))
{
return(Response.NotModified());
}
return(Negotiate
.WithModel(OrderRepresentationMapper.Map(order, linker, Context))
.WithCacheHeaders(order));
}
public CommandModule(ICommandHandler <Person> commandHandler)
{
Post["/api/v1/persons"] = parameters =>
{
PersonDto personDto;
try
{
personDto = this.Bind <PersonDto>();
}
catch
{
return(Negotiate.WithStatusCode(HttpStatusCode.BadRequest));
}
Person person = new Person().Create(personDto.Name, personDto.BirthDay);
if (person == null)
{
return(Negotiate.WithStatusCode(HttpStatusCode.UnprocessableEntity));
}
commandHandler.Execute(person);
return(Response.AsText("Created").WithHeader("Location", $"/api/v1/persons/{person.Id}"));
};
}
public AuthenticationModule(
ICommandSender commandSender,
ITokenEncoder tokenEncoder,
IQueryProcessor queryProcessor)
{
Post("/api/register", async _ => {
var command = this.Bind <RegisterUserCommand>();
await commandSender.Send(command);
var token = new JwtPayload(command.UserId);
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(new {
token = tokenEncoder.Encode(token),
expire = token.Expire
}));
});
Post("/api/login", async _ => {
var userId = this.Request.Form.UserId;
if (string.IsNullOrEmpty(userId))
{
return(Negotiate.WithStatusCode(HttpStatusCode.Unauthorized));
}
var user = await queryProcessor.Query(new FindUserQuery(userId));
if (user == null)
{
return(Negotiate.WithStatusCode(HttpStatusCode.Unauthorized));
}
var token = new JwtPayload(userId);
return(Negotiate
.WithStatusCode(HttpStatusCode.OK)
.WithModel(new {
token = tokenEncoder.Encode(token),
expire = token.Expire
}));
});
}
private dynamic PostToken(dynamic arg)
{
Token model = null;
try
{
model = this.Bind <Token>();
}
catch
{
return(Negotiate.WithModel("Incorrect object structure.").WithStatusCode(HttpStatusCode.BadRequest));
}
string errorMessage = null;
SQLServerBaseDAO.TokenState state = dao.GetTokenState(model);
if (state == SQLServerBaseDAO.TokenState.WrongUser)
{
errorMessage = "User doesn't match token.";
}
if (state == SQLServerBaseDAO.TokenState.Expired)
{
errorMessage = "Token expired.";
}
if (state == SQLServerBaseDAO.TokenState.DoesNotExist)
{
errorMessage = "Token doesn't exist.";
}
if (String.IsNullOrEmpty(errorMessage))
{
return(HttpStatusCode.OK);
}
else
{
return(Negotiate.WithModel(errorMessage).WithStatusCode(HttpStatusCode.Unauthorized));
}
}
public SettingsModule(SettingsManagement settingsMgmt) : base("/api/_settings")
{
_settingsMgmt = settingsMgmt;
Get("/", (p) =>
{
var settings = _settingsMgmt.GetSettings();
return(Negotiate.WithModel(new SettingsRequest
{
PollingInterval = settings.PollingInterval,
PollingSensorsPath = settings.PollingSensorsPath,
PollingTemperatureFile = settings.PollingTemperatureFile,
SensorInsideId = settings.SensorInsideId,
SensorOutsideId = settings.SensorOutsideId,
TargetTemperature = settings.TargetTemperature,
PinCool = settings.PinCool,
PinHeat = settings.PinHeat,
Diff = settings.Diff
}));
});
Put("/", (p) =>
{
var req = this.Bind <SettingsRequest>();
var settings = _settingsMgmt.GetSettings();
settings.PollingInterval = req.PollingInterval == default(int) ? settings.PollingInterval : req.PollingInterval;
settings.PollingSensorsPath = req.PollingSensorsPath ?? settings.PollingSensorsPath;
settings.PollingTemperatureFile = req.PollingTemperatureFile ?? settings.PollingTemperatureFile;
settings.SensorInsideId = req.SensorInsideId ?? settings.SensorInsideId;
settings.SensorOutsideId = req.SensorOutsideId ?? settings.SensorOutsideId;
settings.TargetTemperature = req.TargetTemperature == default(float) ? settings.TargetTemperature : req.TargetTemperature;
settings.PinCool = req.PinCool == default(int) ? settings.PinCool : req.PinCool;
settings.PinHeat = req.PinHeat == default(int) ? settings.PinHeat : req.PinHeat;
settings.Diff = req.Diff == default(float) ? settings.Diff : req.Diff;
settingsMgmt.UpdateSettings(settings);
return(Negotiate.WithStatusCode(HttpStatusCode.OK));
});
}
private async Task <object> CreateMachineAsync(dynamic input, CancellationToken cancellationToken)
{
Machine newMachine;
try
{
newMachine = this.Bind <Machine>();
}
catch (Exception ex)
{
Logger.Info("Binding failed while attempting to create a Machine resource", ex);
return(Response.BadRequestBindingException());
}
await RequiresAccess()
.WithTenantIdExpansion(c => newMachine.TenantId)
.ExecuteAsync(cancellationToken);
try
{
var result = await _machinesController.CreateMachineAsync(newMachine, TenantId, cancellationToken);
return(Negotiate
.WithModel(result)
.WithStatusCode(HttpStatusCode.Created));
}
catch (ValidationFailedException ex)
{
Logger.Debug("Validation failed for CreateMachine", ex);
return(Response.BadRequestValidationFailed(ex.Errors));
}
catch (Exception ex)
{
Logger.Error("Failed to create machine resource due to an error", ex);
return(Response.InternalServerError(ResponseReasons.InternalServerErrorCreateMachine));
}
}
private Task <dynamic> CreateUser(dynamic parameters, CancellationToken ct)
{
return(Task <dynamic> .Factory.StartNew(() =>
{
this.RequiresAuthentication();
this.RequiresAnyClaim(new[] { "superuser", "create-user" });
var userName = (string)Request.Query.UserName ?? (string)Request.Form.UserName;
var password = (string)Request.Query.Password ?? (string)Request.Form.Password;
using (var transaction = _connection.OpenTransaction())
{
//Find the user with the given name (and correct password)
var user = _connection.Select <User>(a => a.Username == userName).SingleOrDefault();
if (user != null)
{
return Negotiate
.WithModel(new { Error = "User With This Username Already Exists" })
.WithStatusCode(HttpStatusCode.Conflict);
}
//Create a new user
user = new User(userName, password);
_connection.Save(user);
// HACK: TEMP ADDING SUPERUSER CLAIM
_connection.Save(new Claim(user, "superuser"));
//Save any changes made
transaction.Commit();
//Return the user
return SerializeUser(user);
}
}, ct));
}
private object InsertPerson(dynamic newPerson)
{
ViewModelPerson userInfo = this.Bind <ViewModelPerson>();
ModelValidationResult validationResult = this.Validate(userInfo);
if (!validationResult.IsValid)
{
_logger.Error("[{Timestamp:HH:mm:ss} is not validated]", JsonSerializer.Serialize(userInfo, typeof(ViewModelPerson)));
return(Negotiate.WithModel(validationResult).WithStatusCode(HttpStatusCode.BadRequest));
}
var inserteePerson = new Person(_ageComputingFactory)
{
GUID = Guid.NewGuid().ToString("D"), Birthday = DateTime.Parse(userInfo.Birthday), Name = userInfo.Name
};
_personRepository.Insert(inserteePerson);
_logger.Information("[{Timestamp:HH:mm:ss} added to database]", JsonSerializer.Serialize(inserteePerson, typeof(Person)));
// Created + заголовок Location /api/v1/persons/{person_id}, если команда выполнена
return($"Created {HttpStatusCode.OK} {ModulePath}/persons/{inserteePerson.GUID}");
}
private dynamic UpdateTodo(dynamic parameters)
{
var todo = repo.Get(parameters.id) as Todo;
// TODO : need to figure out a good way of binding parameter updates
var update = this.Bind <Todo>();
if (!string.IsNullOrEmpty(update.Title))
{
todo.Title = update.Title;
}
if (update.Order.HasValue)
{
todo.Order = update.Order.Value;
}
if (update.Completed.HasValue)
{
todo.Completed = update.Completed.Value;
}
repo.Update(todo);
return(Negotiate.WithModel(repo.Get(parameters.id) as Todo)
.WithStatusCode(HttpStatusCode.Created));
}
