将Json回传数据转换为XML

这是我第一个Web应用项目。我使用的是VS Community、asp.net、Bootstrap 4、C#和JS Knockout作为我的视图模型，服务器端数据来自于公司ERP SQL数据库，使用Entity Framework。

我的想法是让用户从公司ERP系统中接收一个待批准的项目列表，这些项目将被加载到视图模型中。视图模型结构为JS Knockout可见数组，每个项目都是JS Knockout可见项目（见下面的完整代码）。

一旦用户按照预期处理了项目，我希望Web应用程序以整个视图模式作为Json对象进行发布，并且服务器Post Controller将接收此Json对象将其转换为XML以将其发送到SQL存储过程以插入SQL数据库，从SQL数据库中处理数据并插入ERP数据库

当我尝试执行发布时，我会得到一个405“方法不允许”的错误

> "tags": {
    "ai.cloud.roleInstance": "[MYCOMPUTER].local",
    "ai.operation.id": "c07680cd8c845240a9e3791018c39521",
    "ai.operation.name": "POST ReqsTests",
    "ai.location.ip": "::1",
    "ai.internal.sdkVersion": "web:2.8.0-241",
    "ai.internal.nodeName": "[MYCOMPUTER].local"
  },
  "data": {
    "baseType": "RequestData",
    "baseData": {
      "ver": 2,
      "id": "|c07680cd8c845240a9e3791018c39521.66f8d951_",
      "name": "POST ReqsTests",
      "duration": "00:00:00.0279394",
      "success": false,
      "responseCode": "405",
      "url": "http://localhost:64234/api/ReqsTests/",
      "properties": {
        "DeveloperMode": "true",
        "_MS.ProcessedByMetricExtractors": "(Name:'Requests', Ver:'1.1')"
      }
    }
  }
}

我认为我没有正确地从客户端收到Json日期。我认为，因为我发送整个模型，这是一个Json列表，但我的控制器没有接收到列表，而是一个字符串。

有人能解释一下我的控制器应该如何接收客户端数据吗？

这是我的客户端对控制器的调用以及服务器Post控制器和完整代码列表

 self.postAllReqs = function(self) {
        self.error(''); // Clear error message
        var data = ko.toJSON(self.Reqs); // convert to json
        console.log(data);
        ajaxHelper(reqsUri, 'POST', data).fail(function (jqXHR, textStatus, errorThrown) {
            self.error(errorThrown);
        });
    }
  // POST: api/ReqsTests
    public IHttpActionResult PostReqsTest(string json)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        XmlDocument doc = JsonConvert.DeserializeXmlNode(json);
        try
        {
            //SQL store procedure
            SqlParameter param1 = new SqlParameter("@XmlIn", doc);
            db.Database.ExecuteSqlCommand("exec [CHC_Web].[TestWebHandShake],@XmlIn",
                                          param1);
        }
        catch (Exception e)
        {
            string message = e.Message;
              return ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, message));                 
        }
        return Ok();
    }

谢谢

视图模型代码

    function ReqsTest(rt) {
    rt = rt || {};
    var self = this;
    self.id = ko.observable(rt.ID || 0);
    self.requisition = ko.observable(rt.Requisition || "");
    self.reqnStatus = ko.observable(rt.ReqnStatus || "");
    self.dateReqnRaised = ko.observable(rt.DateReqnRaised|| null);
    self.reqnValue = ko.observable(rt.ReqnValue || null);
    self.approvedValue = ko.observable(rt.ApprovedValue || null);
    self.originator = ko.observable(rt.Originator || "");
    self.origName = ko.observable(rt.OrigName || "");
    self.origEmail = ko.observable(rt.OrigEmail || "");
    self.line = ko.observable(rt.Line || 0.00);
    self.indx = ko.observable(rt.INDX || 0);
    self.dateReqnRaisedL = ko.observable(rt.DateReqnRaisedL || null);
    self.reqStatus = ko.observable(rt.ReqStatus || "");
    //self.reqBackground = ko.observable(rt.ReqBackground || "");
    //Computed observables
    self.reqBackground = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "A") { return "card-heading bg-success text-white"; }
        else if (status == "D") { return "card heading bg-secondary"; }
        else if (status == "R") { return "card heading bg-warning"; }
        else if (status == "E") { return "card heading bg-danger"; }
        else {
            return "card-heading bg-primary text-white";
        }
    })
    self.reqStatusLabel = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "A") { return "Approved"; }
        else if (status == "D") { return "Declined - put on hold"; }
        else if (status == "R") { return "Routing On"; }
        else if (status == "E") { return "Erase On Syspro"; }
        else {
            return "Awaiting Approval";
        }
    })
    self.approvalBtn = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "A") { return "css: button btn-secondary "; }
        else {
            return "btn btn-success ";
        }
    })
    self.approvalBtnLbl = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "W") { return "Approve"; }
        else {
            return "UnApprove";
        }
    })
    self.declineBtnLbl = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "D") { return "UnDecline"; }
        else {
            return "Decline";
        }
    })
    self.deleteBtnLbl = ko.computed(function () {
        // get variable 
        var status = self.reqStatus();
        if (status == "E") { return "Restore"; }
        else {
            return "Erase";
        }
    })
    // Functions
    //show details alert
    $(".btn").on("click", function () {
        $(".alert").removeClass("in").show();
        $(".alert").delay(200).addClass("in").fadeOut(2000);
    });
}
function ReqsViewModel (){
    var self = this;
    self.Reqs = ko.observableArray([]);
    self.error = ko.observable();
    var reqsUri = '/api/ReqsTests/';
    function ajaxHelper(uri, method, data) {
        self.error(''); // Clear error message
        return $.ajax({
            type: method,
            url: uri,
            dataType: 'json',
            contentType: 'application/json',
            data: data ? JSON.stringify(data) : null
        }).fail(function (jqXHR, textStatus, errorThrown) {
            self.error(errorThrown);
        });
    }
    function getAllReqs() {
        ajaxHelper(reqsUri, 'GET').done(function (data) {
            // Build the ReqsTest objects
            var reqs = ko.utils.arrayMap(data, function (rt) {
                return new ReqsTest(rt);
            });
            self.Reqs(reqs);
        });
    }
self.postAllReqs = function(self) {
        self.error(''); // Clear error message
        var data = ko.toJSON(self.Reqs); // convert to json
        console.log(data);
        ajaxHelper(reqsUri, 'POST', data).fail(function (jqXHR, textStatus, errorThrown) {
            self.error(errorThrown);
        });
    }
     // Details
    self.detail = ko.observable();
    self.getReqDetail = function (item) {
        //var url = reqsUri + item.indx();
        //ajaxHelper(url, 'GET').done(function (data) {
        //    self.detail(data);
        //}
        //);
        self.detail(item)
    }
    //Approval function
    self.Approval = function (item) {
        var status = item.reqStatus();
        if (status == "W") { item.reqStatus("A"); }
        else
        { item.reqStatus("W"); }
        self.getReqDetail(item);
    }
    //Decline function
    self.Decline = function (item) {
        var status = item.reqStatus();
        if (status == "D") { item.reqStatus("W"); }
        else { item.reqStatus("D"); }
        self.getReqDetail(item);
    }
    //Delete function
    self.Delete = function (item) {
        var status = item.reqStatus();
        if (status == "E") { item.reqStatus("W"); }
        else { item.reqStatus("E"); }
        self.getReqDetail(item);
    }
    // Load the reqs - Take this out if you don't want it
    getAllReqs();
}
ko.applyBindings(new ReqsViewModel());

模型类

 namespace POC_Reqs_v1.Models
{
    using System;
    using System.Collections.Generic;
    public partial class ReqsTest
    {
        public string ID { get; set; }
        public string Requisition { get; set; }
        public string ReqnStatus { get; set; }
        public Nullable DateReqnRaised { get; set; }
        public Nullable ReqnValue { get; set; }
        public Nullable ApprovedValue { get; set; }
        public string Originator { get; set; }
        public string OrigName { get; set; }
        public string OrigEmail { get; set; }
        public decimal Line { get; set; }
        public long INDX { get; set; }
        public string DateReqnRaisedL { get; set; }
        public string ReqStatus { get; set; }
        public string ReqBackground { get; set; }
    }
}

控制器代码

  using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.Http.Description;
using System.Xml;
using Newtonsoft.Json;
using POC_Reqs_v1.Models;
namespace POC_Reqs_v1.Controllers
{
    public class ReqsTestsController : ApiController
    {
        private ChamberlinWebEntities db = new ChamberlinWebEntities();
        // GET: api/ReqsTests
        public IQueryable GetReqsTests()
        {
            return db.ReqsTests;
        }
        // GET: api/ReqsTests/5
        [ResponseType(typeof(ReqsTest))]
        public async Task GetReqsTest(string id)
        {
            var ID = Convert.ToInt64(id);
            ReqsTest reqsTest = await db.ReqsTests.FindAsync(ID);
            if (reqsTest == null)
            {
                return NotFound();
            }
            return Ok(reqsTest);
        }
        // PUT: api/ReqsTests/5
        [ResponseType(typeof(void))]
        public async Task PutReqsTest(string id, ReqsTest reqsTest)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            if (id != reqsTest.ID)
            {
                return BadRequest();
            }
            db.Entry(reqsTest).State = EntityState.Modified;
            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!ReqsTestExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }
            return StatusCode(HttpStatusCode.NoContent);
        }
        // POST: api/ReqsTests
    public IHttpActionResult PostReqsTest(string json)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        XmlDocument doc = JsonConvert.DeserializeXmlNode(json);
        try
        {
            //SQL store procedure
            SqlParameter param1 = new SqlParameter("@XmlIn", doc);
            db.Database.ExecuteSqlCommand("exec [CHC_Web].[TestWebHandShake],@XmlIn",
                                          param1);
        }
        catch (Exception e)
        {
            string message = e.Message;
              return ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, message));                 
        }
        return Ok();
    }
        // DELETE: api/ReqsTests/5
        [ResponseType(typeof(ReqsTest))]
        public async Task DeleteReqsTest(string id)
        {
            ReqsTest reqsTest = await db.ReqsTests.FindAsync(id);
            if (reqsTest == null)
            {
                return NotFound();
            }
            db.ReqsTests.Remove(reqsTest);
            await db.SaveChangesAsync();
            return Ok(reqsTest);
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
        private bool ReqsTestExists(string id)
        {
            return db.ReqsTests.Count(e => e.ID == id) > 0;
        }
    }
}