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