ASP.NET MVC: DataSource на JavaScript для работы с Web API или снова про JsSite

   1:  (function (site) {

   2:   

   3:      site.services.documents = function () {

   4:  var

   5:              init = function () {

   6:                  site.amplify.request.define("getdocument", "ajax", {

   7:                      url: "/api/documentapi",

   8:                      dataType: "json",

   9:                      type: "GET",

  10:                      cache: false

  11:                  });

  12:                  site.amplify.request.define("postdocument", "ajax", {

  13:                      url: "/api/documentapi",

  14:                      dataType: "json",

  15:                      contentType: "application/json; charset=utf-8",

  16:                      type: "POST",

  17:                      cache: false

  18:                  });

  19:                  site.amplify.request.define("putdocument", "ajax", {

  20:                      url: "/api/documentapi",

  21:                      dataType: "json",

  22:                      contentType: "application/json; charset=utf-8",

  23:                      type: "PUT",

  24:                      cache: false

  25:                  });

  26:                  site.amplify.request.define("deldocument", "ajax", {

  27:                      url: "/api/documentapi",

  28:                      dataType: "json",

  29:                      contentType: "application/json; charset=utf-8",

  30:                      type: "DELETE",

  31:                      cache: false

  32:                  });

  33:              },

  34:              mapItem = function (data) {

  35:  returnnew site.m.Document(data);

  36:              },

  37:              mapItems = function (data) {

  38:  var mapped = [];

  39:                  site._.each(data, function (item) {

  40:                      mapped.push(mapItem(item));

  41:                  });

  42:  return mapped;

  43:              },

  44:              getData = function (params, back) {

  45:  if (typeof back !== "function") thrownew Error("callback not a function");

  46:  if (!params) thrownew Error("queryParams notis null");

  47:  return site.amplify.request({

  48:                      resourceId: "getdocument",

  49:                      data: { qp: ko.toJSON(params) },

  50:                      success: function (json) {

  51:  if (json) {

  52:  if (json.success) {

  53:  params.total(json.total);

  54:  var result = mapItems(json.items);

  55:                                  back(result);

  56:  return;

  57:                              }

  58:  if (json.warning) {

  59:                                  site.logger.warning(json.warning);

  60:                              }

  61:  if (json.error) {

  62:                                  site.logger.error(json.error);

  63:                              }

  64:                          }

  65:                          back();

  66:                      },

  67:                      error: function () {

  68:                          site.logger.error("Ошибка загрузки сущности \"Документ\");

  69:                          back();

  70:                      }

  71:                  });

  72:              },

  73:              getDataById = function (params, back) {

  74:  if (typeof back !== "function") thrownew Error("callback not a function");

  75:  if (!params) thrownew Error("queryParams notis null");

  76:  return site.amplify.request({

  77:                      resourceId: "getdocument",

  78:                      data: { id: params },

  79:                      success: function (json) {

  80:  if (json) {

  81:  if (json.success) {

  82:  var result = mapItem(json.item);

  83:                                  back(result);

  84:  return;

  85:                              }

  86:  if (json.warning) {

  87:                                  site.logger.warning(json.warning);

  88:                              }

  89:  if (json.error) {

  90:                                  site.logger.error(json.error);

  91:                              }

  92:                          }

  93:                          back();

  94:                      },

  95:                      error: function () {

  96:                          site.logger.error("Ошибка загрузки сущности \"Должность\");

  97:                          back();

  98:                      }

  99:                  });

 100:              },

 101:              postData = function (params, back) {

 102:  if (typeof back !== "function") thrownew Error("callback not a function");

 103:  return site.amplify.request({

 104:                      resourceId: "postdocument",

 105:                      data: ko.toJSON(params),

 106:                      success: function (json) {

 107:  if (json) {

 108:  if (json.success) {

 109:                                  site.logger.success(json.success);

 110:                                  back(new mapItem(json.item));

 111:  return;

 112:                              }

 113:  if (json.warning) {

 114:                                  site.logger.warning(json.warning);

 115:                              }

 116:  if (json.error) {

 117:                                  site.logger.error(json.error);

 118:                              }

 119:                          }

 120:                          back();

 121:                      },

 122:                      error: function () {

 123:                          site.logger.error("Ошибка сохранения сущности \"Документ\"");

 124:                          back();

 125:                      }

 126:                  });

 127:              },

 128:              putData = function (params, back) {

 129:  if (typeof back !== "function") thrownew Error("callback not a function");

 130:  return site.amplify.request({

 131:                      resourceId: "putdocument",

 132:                      data: ko.toJSON(params),

 133:                      success: function (json) {

 134:  if (json) {

 135:  if (json.success) {

 136:                                  site.logger.success(json.success);

 137:                                  back(new mapItem(json.item));

 138:  return;

 139:                              }

 140:  if (json.warning) {

 141:                                  site.logger.warning(json.warning);

 142:                              }

 143:  if (json.error) {

 144:                                  site.logger.error(json.error);

 145:                              }

 146:                          }

 147:                          back();

 148:                      },

 149:                      error: function () {

 150:                          site.logger.error("Ошибка обновления сущности \"Документ\");

 151:                          back();

 152:                      }

 153:                  });

 154:              },

 155:              delData = function (params, back) {

 156:  if (typeof back !== "function") thrownew Error("callback not a function");

 157:  return site.amplify.request({

 158:                      resourceId: "deldocument",

 159:                      data: ko.toJSON(params),

 160:                      success: function (json) {

 161:  if (json) {

 162:  if (json.success) {

 163:                                  site.logger.success(json.success);

 164:                                  back(new mapItem(json.item));

 165:  return;

 166:                              }

 167:  if (json.warning) {

 168:                                  site.logger.warning(json.warning);

 169:                              }

 170:  if (json.error) {

 171:                                  site.logger.error(json.error);

 172:                              }

 173:                          }

 174:                          back();

 175:                      },

 176:                      error: function () {

 177:                          site.logger.error("Ошибка удаления сущности \"Документ\");

 178:                          back();

 179:                      }

 180:                  });

 181:              };

 182:   

 183:          init();

 184:   

 185:  return {

 186:              getDataById: getDataById,

 187:              postData: postData,

 188:              getData: getData,

 189:              putData: putData,

 190:              delData: delData

 191:          };

 192:      }();

 193:   

 194:  })(site);

• Комментарии