How to use serializePostData method in Playwright Internal

1const { User, Post, Order } = require("../../models");
2
3const renderDashboard = async (req, res) => {
4  try {
5    const { loggedIn } = req.session;
6    const data = await Post.findAll({
7      include: [{ model: User }],
8      // raw: true,
9    });
10
11    const serializedData = {
12      loggedIn,
13      posts: data.map((posts) => posts.get({ plain: true })),
14    };
15
16    // console.log(serializedData);
17
18    res.render("dashboard", serializedData);
19  } catch (error) {
20    const errorMessage = "Failed to render dashboard data";
21    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
22    // return res.status(500).json({
23    //   success: false,
24    //   message: errorMessage,
25    // });
26  }
27};
28
29const renderFoodPostById = async (req, res) => {
30  try {
31    const { loggedIn } = req.session;
32
33    const username = req.session.user.username;
34
35    const { postId } = req.params;
36
37    const foodPostData = await Post.findAll({
38      where: { uuid: postId },
39      include: [{ model: User }],
40      // raw: true,
41    });
42
43    const serializedData = {
44      loggedIn,
45      posts: foodPostData.map((posts) => posts.get({ plain: true }))[0],
46      // foodPostData,
47    };
48
49    console.log(serializedData);
50
51    // if (!blogData) {
52    //   return res.render("no-blog");
53    // }
54
55    return res.render("food-post", serializedData);
56  } catch (error) {
57    console.log(error.message);
58  }
59};
60
61const renderEditFoodPostById = async (req, res) => {
62  try {
63    const { loggedIn } = req.session;
64
65    const { postId } = req.params;
66
67    const foodPostData = await Post.findOne({
68      where: { uuid: postId },
69      raw: true,
70    });
71
72    // if (!foodPostData) {
73    //   return res.render("no-blog");
74    // }
75
76    console.log(foodPostData);
77
78    const data = { loggedIn, ...foodPostData };
79
80    res.render("edit-post", data);
81  } catch (error) {
82    console.log(error.message);
83  }
84};
85
86const renderFoodPostForm = (req, res) => {
87  res.render("create-food-post");
88};
89
90const renderOrderForm = async (req, res) => {
91  try {
92    const { loggedIn } = req.session;
93    const { postId } = req.params;
94
95    const postData = await Post.findAll({
96      where: { uuid: postId },
97      include: [{ model: User }],
98      // raw: true,
99    });
100
101    const serializePostData = postData.map((posts) =>
102      posts.get({ plain: true })
103    )[0];
104
105    // const data = await Order.findAll({
106    //   where: { post_id: serializePostData.id },
107    //   include: [{ model: Post }],
108    //   // raw: true,
109    // });
110
111    const serializedData = {
112      loggedIn,
113      serializePostData,
114      userInfo: {
115        name: req.session.user.full_name,
116        email: req.session.user.email,
117        username: req.session.user.username,
118        location: req.session.user.location,
119        profileImage: req.session.user.profileImg,
120      },
121    };
122
123    console.log("Serialized data:", serializedData);
124    res.render("order-form", serializedData);
125  } catch (error) {
126    const errorMessage = "Failed to render profile data";
127    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
128    // return res.status(500).json({
129    //   success: false,
130    //   message: errorMessage,
131    // });
132  }
133};
134
135const renderProfilePage = async (req, res) => {
136  try {
137    const { loggedIn } = req.session;
138    const data = await Post.findAll({
139      where: { user_id: req.session.user.id },
140      include: [{ model: User }],
141      // raw: true,
142    });
143
144    const orderData = await Order.findAll({
145      where: { user_id: req.session.user.id },
146      include: [{ model: Post }],
147      // raw: true,
148    });
149
150    const serializedData = {
151      loggedIn,
152      posts: data.map((posts) => posts.get({ plain: true })),
153      order: orderData.map((orders) => orders.get({ plain: true })),
154      userInfo: {
155        name: req.session.user.full_name,
156        location: req.session.user.location,
157        profileUrl: req.session.user.profileImg,
158      },
159    };
160
161    // console.log(serializedData);
162
163    res.render("profile-page", serializedData);
164  } catch (error) {
165    const errorMessage = "Failed to render profile data";
166    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
167    // return res.status(500).json({
168    //   success: false,
169    //   message: errorMessage,
170    // });
171  }
172};
173
174const renderProfilePosts = async (req, res) => {
175  try {
176    const { loggedIn } = req.session;
177    const data = await Post.findAll({
178      where: { user_id: req.session.user.id },
179      include: [{ model: User }],
180      // raw: true,
181    });
182
183    const serializedData = {
184      loggedIn,
185      posts: data.map((posts) => posts.get({ plain: true })),
186      userInfo: {
187        name: req.session.user.full_name,
188        location: req.session.user.location,
189        profileUrl: req.session.user.profileImg,
190      },
191    };
192
193    // console.log(serializedData);
194
195    res.render("profile-posts", serializedData);
196  } catch (error) {
197    const errorMessage = "Failed to render profile data";
198    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
199    // return res.status(500).json({
200    //   success: false,
201    //   message: errorMessage,
202    // });
203  }
204};
205
206const renderProfileOrders = async (req, res) => {
207  try {
208    const { loggedIn } = req.session;
209    const data = await Order.findAll({
210      where: { user_id: req.session.user.id },
211      include: [{ model: Post }],
212      // raw: true,
213    });
214
215    const serializedData = {
216      loggedIn,
217      order: data.map((orders) => orders.get({ plain: true })),
218      userInfo: {
219        name: req.session.user.full_name,
220      },
221    };
222
223    console.log(serializedData);
224
225    res.render("profile-orders", serializedData);
226  } catch (error) {
227    const errorMessage = "Failed to render profile data";
228    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
229    // return res.status(500).json({
230    //   success: false,
231    //   message: errorMessage,
232    // });
233  }
234};
235
236const renderUserProfilePage = async (req, res) => {
237  try {
238    const { username } = req.params;
239
240    console.log(username);
241
242    const userData = await User.findOne({
243      where: { username: username },
244      include: [{ model: Post }],
245      // raw: true,
246    });
247
248    const postInfo = userData.get({ plain: true });
249
250    console.log(postInfo);
251
252    // console.log(userData, username, `all data`);
253
254    // const data = await Post.findAll({
255    //   where: { user_id: postIdData.id },
256    //   include: [{ model: User }],
257    // });
258
259    // const serializedData = {
260    //   posts: data.map((posts) => posts.get({ plain: true })),
261    //   postIdData,
262    // };
263
264    res.render("user-profile", { postInfo });
265  } catch (error) {
266    const errorMessage = "Failed to render profile data";
267    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
268    // return res.status(500).json({
269    //   success: false,
270    //   message: errorMessage,
271    // });
272  }
273};
274
275const renderInbox = (req, res) => {
276  // try {
277  //   const { loggedIn } = req.session;
278  //   const { postId } = req.params;
279
280  //   const postData = await Post.findAll({
281  //     where: { uuid: postId },
282  //     include: [{ model: User }],
283  //     // raw: true,
284  //   });
285
286  //   const serializePostData = postData.map((posts) =>
287  //     posts.get({ plain: true })
288  //   )[0];
289
290  //   const data = await Order.findAll({
291  //     where: { post_id: serializePostData.id },
292  //     include: [{ model: Post }],
293  //     // raw: true,
294  //   });
295
296  //   const serializedData = {
297  //     loggedIn,
298  //     order: data.map((orders) => orders.get({ plain: true }))[0],
299  //     userInfo: {
300  //       name: req.session.user.full_name,
301  //       email: req.session.user.email,
302  //       username: req.session.user.username,
303  //       location: req.session.user.location,
304  //       profileImage: req.session.user.profileImg,
305  //     },
306  //   };
307
308  //   console.log("Serialized data:", serializedData);
309  //   res.render("inbox", serializedData);
310  // } catch (error) {
311  //   const errorMessage = "Failed to render profile data";
312  //   console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
313  //   // return res.status(500).json({
314  //   //   success: false,
315  //   //   message: errorMessage,
316  //   // });
317  // }
318
319  res.render("inbox");
320};
321
322module.exports = {
323  renderDashboard,
324  renderFoodPostById,
325  renderFoodPostForm,
326  renderEditFoodPostById,
327  renderOrderForm,
328  renderProfilePage,
329  renderProfileOrders,
330  renderProfilePosts,
331  renderUserProfilePage,
332  renderInbox,
333};
334
335// const renderOrderForm = async (req, res) => {
336//   try {
337//     const { loggedIn } = req.session;
338//     const { postId } = req.params;
339
340//     const postData = await Post.findAll({
341//       where: { uuid: postId },
342//       include: [{ model: User }],
343//       // raw: true,
344//     });
345
346//     const serializePostData = postData.map((posts) =>
347//       posts.get({ plain: true })
348//     )[0];
349
350//     const data = await Order.findAll({
351//       where: { post_id: serializePostData.id },
352//       include: [{ model: Post }],
353//       // raw: true,
354//     });
355
356//     const serializedData = {
357//       loggedIn,
358//       order: data.map((orders) => orders.get({ plain: true }))[0],
359//       userInfo: {
360//         name: req.session.user.full_name,
361//         email: req.session.user.email,
362//         username: req.session.user.username,
363//         location: req.session.user.location,
364//         profileImage: req.session.user.profileImg,
365//       },
366//     };
367
368//     console.log("Serialized data:", serializedData);
369//     res.render("order-form", serializedData);
370//   } catch (error) {
371//     const errorMessage = "Failed to render profile data";
372//     console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
373//     // return res.status(500).json({
374//     //   success: false,
375//     //   message: errorMessage,
376//     // });
377//   }
378// };
379

Source: private-controller.js

const { User, Post, Order } = require("../../models");

const renderDashboard = async (req, res) => {
  try {
    const { loggedIn } = req.session;
    const data = await Post.findAll({
      include: [{ model: User }],
      // raw: true,
    });

    const serializedData = {
      loggedIn,
      posts: data.map((posts) => posts.get({ plain: true })),
    };

    // console.log(serializedData);

    res.render("dashboard", serializedData);
  } catch (error) {
    const errorMessage = "Failed to render dashboard data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderFoodPostById = async (req, res) => {
  try {
    const { loggedIn } = req.session;

    const username = req.session.user.username;

    const { postId } = req.params;

    const foodPostData = await Post.findAll({
      where: { uuid: postId },
      include: [{ model: User }],
      // raw: true,
    });

    const serializedData = {
      loggedIn,
      posts: foodPostData.map((posts) => posts.get({ plain: true }))[0],
      // foodPostData,
    };

    console.log(serializedData);

    // if (!blogData) {
    //   return res.render("no-blog");
    // }

    return res.render("food-post", serializedData);
  } catch (error) {
    console.log(error.message);
  }
};

const renderEditFoodPostById = async (req, res) => {
  try {
    const { loggedIn } = req.session;

    const { postId } = req.params;

    const foodPostData = await Post.findOne({
      where: { uuid: postId },
      raw: true,
    });

    // if (!foodPostData) {
    //   return res.render("no-blog");
    // }

    console.log(foodPostData);

    const data = { loggedIn, ...foodPostData };

    res.render("edit-post", data);
  } catch (error) {
    console.log(error.message);
  }
};

const renderFoodPostForm = (req, res) => {
  res.render("create-food-post");
};

const renderOrderForm = async (req, res) => {
  try {
    const { loggedIn } = req.session;
    const { postId } = req.params;

    const postData = await Post.findAll({
      where: { uuid: postId },
      include: [{ model: User }],
      // raw: true,
    });

    const serializePostData = postData.map((posts) =>
      posts.get({ plain: true })
    )[0];

    // const data = await Order.findAll({
    //   where: { post_id: serializePostData.id },
    //   include: [{ model: Post }],
    //   // raw: true,
    // });

    const serializedData = {
      loggedIn,
      serializePostData,
      userInfo: {
        name: req.session.user.full_name,
        email: req.session.user.email,
        username: req.session.user.username,
        location: req.session.user.location,
        profileImage: req.session.user.profileImg,
      },
    };

    console.log("Serialized data:", serializedData);
    res.render("order-form", serializedData);
  } catch (error) {
    const errorMessage = "Failed to render profile data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderProfilePage = async (req, res) => {
  try {
    const { loggedIn } = req.session;
    const data = await Post.findAll({
      where: { user_id: req.session.user.id },
      include: [{ model: User }],
      // raw: true,
    });

    const orderData = await Order.findAll({
      where: { user_id: req.session.user.id },
      include: [{ model: Post }],
      // raw: true,
    });

    const serializedData = {
      loggedIn,
      posts: data.map((posts) => posts.get({ plain: true })),
      order: orderData.map((orders) => orders.get({ plain: true })),
      userInfo: {
        name: req.session.user.full_name,
        location: req.session.user.location,
        profileUrl: req.session.user.profileImg,
      },
    };

    // console.log(serializedData);

    res.render("profile-page", serializedData);
  } catch (error) {
    const errorMessage = "Failed to render profile data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderProfilePosts = async (req, res) => {
  try {
    const { loggedIn } = req.session;
    const data = await Post.findAll({
      where: { user_id: req.session.user.id },
      include: [{ model: User }],
      // raw: true,
    });

    const serializedData = {
      loggedIn,
      posts: data.map((posts) => posts.get({ plain: true })),
      userInfo: {
        name: req.session.user.full_name,
        location: req.session.user.location,
        profileUrl: req.session.user.profileImg,
      },
    };

    // console.log(serializedData);

    res.render("profile-posts", serializedData);
  } catch (error) {
    const errorMessage = "Failed to render profile data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderProfileOrders = async (req, res) => {
  try {
    const { loggedIn } = req.session;
    const data = await Order.findAll({
      where: { user_id: req.session.user.id },
      include: [{ model: Post }],
      // raw: true,
    });

    const serializedData = {
      loggedIn,
      order: data.map((orders) => orders.get({ plain: true })),
      userInfo: {
        name: req.session.user.full_name,
      },
    };

    console.log(serializedData);

    res.render("profile-orders", serializedData);
  } catch (error) {
    const errorMessage = "Failed to render profile data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderUserProfilePage = async (req, res) => {
  try {
    const { username } = req.params;

    console.log(username);

    const userData = await User.findOne({
      where: { username: username },
      include: [{ model: Post }],
      // raw: true,
    });

    const postInfo = userData.get({ plain: true });

    console.log(postInfo);

    // console.log(userData, username, `all data`);

    // const data = await Post.findAll({
    //   where: { user_id: postIdData.id },
    //   include: [{ model: User }],
    // });

    // const serializedData = {
    //   posts: data.map((posts) => posts.get({ plain: true })),
    //   postIdData,
    // };

    res.render("user-profile", { postInfo });
  } catch (error) {
    const errorMessage = "Failed to render profile data";
    console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
    // return res.status(500).json({
    //   success: false,
    //   message: errorMessage,
    // });
  }
};

const renderInbox = (req, res) => {
  // try {
  //   const { loggedIn } = req.session;
  //   const { postId } = req.params;

  //   const postData = await Post.findAll({
  //     where: { uuid: postId },
  //     include: [{ model: User }],
  //     // raw: true,
  //   });

  //   const serializePostData = postData.map((posts) =>
  //     posts.get({ plain: true })
  //   )[0];

  //   const data = await Order.findAll({
  //     where: { post_id: serializePostData.id },
  //     include: [{ model: Post }],
  //     // raw: true,
  //   });

  //   const serializedData = {
  //     loggedIn,
  //     order: data.map((orders) => orders.get({ plain: true }))[0],
  //     userInfo: {
  //       name: req.session.user.full_name,
  //       email: req.session.user.email,
  //       username: req.session.user.username,
  //       location: req.session.user.location,
  //       profileImage: req.session.user.profileImg,
  //     },
  //   };

  //   console.log("Serialized data:", serializedData);
  //   res.render("inbox", serializedData);
  // } catch (error) {
  //   const errorMessage = "Failed to render profile data";
  //   console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
  //   // return res.status(500).json({
  //   //   success: false,
  //   //   message: errorMessage,
  //   // });
  // }

  res.render("inbox");
};

module.exports = {
  renderDashboard,
  renderFoodPostById,
  renderFoodPostForm,
  renderEditFoodPostById,
  renderOrderForm,
  renderProfilePage,
  renderProfileOrders,
  renderProfilePosts,
  renderUserProfilePage,
  renderInbox,
};

// const renderOrderForm = async (req, res) => {
//   try {
//     const { loggedIn } = req.session;
//     const { postId } = req.params;

//     const postData = await Post.findAll({
//       where: { uuid: postId },
//       include: [{ model: User }],
//       // raw: true,
//     });

//     const serializePostData = postData.map((posts) =>
//       posts.get({ plain: true })
//     )[0];

//     const data = await Order.findAll({
//       where: { post_id: serializePostData.id },
//       include: [{ model: Post }],
//       // raw: true,
//     });

//     const serializedData = {
//       loggedIn,
//       order: data.map((orders) => orders.get({ plain: true }))[0],
//       userInfo: {
//         name: req.session.user.full_name,
//         email: req.session.user.email,
//         username: req.session.user.username,
//         location: req.session.user.location,
//         profileImage: req.session.user.profileImg,
//       },
//     };

//     console.log("Serialized data:", serializedData);
//     res.render("order-form", serializedData);
//   } catch (error) {
//     const errorMessage = "Failed to render profile data";
//     console.log(`[ERROR]: ${errorMessage} | ${error.message}`);
//     // return res.status(500).json({
//     //   success: false,
//     //   message: errorMessage,
//     // });
//   }
// };

1var URL = "categories"
2$(function() {
3
4  $.extend($.jgrid.edit, {
5      mtype: 'PUT'
6    });
7  $.extend($.jgrid.add, {
8      mtype: 'POST'
9    });
10  $.extend($.jgrid.del, {
11      mtype: 'DELETE'
12    });
13
14  function serializePostData(postdata) {
15    var tmp = {};
16    $.extend(tmp, postdata);
17    postdata.category = {};
18    for(var key in tmp) {
19      if (key == "name" || key == "category_id")
20        postdata.category[key] = postdata[key];
21    }
22  }
23
24  var editOptions = {
25      onclickSubmit: function(params, postdata) {
26        serializePostData(postdata);
27        params.url = URL + '/' + postdata.id + ".json";
28      },
29      closeAfterEdit: true
30    };
31
32  var addOptions = {
33    mtype: "POST",
34    onclickSubmit: function(params, postdata) {
35      serializePostData(postdata);
36      params.url = URL + ".json";
37    },
38    closeAfterAdd: true
39  };
40
41  var delOptions = {
42      onclickSubmit: function(params, postdata) {
43        postdata = postdata.toString();
44
45        params.url = URL + '/' + postdata + ".json";
46      }
47    };
48
49  var searchOptions = {
50    onclickSubmit: function(params, postdata) {
51      params.url = URL + '/' + postdata + ".json";
52    },
53    multipleSearch: true,
54    showQuery: true
55  }
56
57  $("#tree_grid_categories").jqGrid({
58      treeGrid: true,
59      url: URL + ".json",
60      editurl: URL,
61      datatype: 'json',
62      mtype: 'GET',
63      treeGridModel: "adjacency",
64      // loadonce: true,
65      ExpandColClick: true,
66      width: "250",
67      height: "auto",
68      ExpandColumn : 'name',
69      colModel: [
70        {name:'id', index:'id', hidden: true},
71        {name:'name', index:'name', label:'Name', editrules: {required: true}, editable: true, autowidth: true},
72        {
73          name:'category_id',
74          index:'category_id',
75          hidden: true,
76          label:'Parent category',
77          edittype: "select",
78          editrules: {edithidden: true},
79          editoptions: {dataUrl: "categories.js"},
80          editable: true,
81          autowidth: true
82        }
83      ],
84      pager: '#pager_categories',
85      onSelectRow: function(row_id) {
86        node_id = $("#tree_grid_categories").getCell(row_id, "id");
87        $.get("products.js", {"nodeid": node_id}, function(data) {
88          $("#table_products").html(data);
89        }, "html");
90      },
91      caption: 'Categories'
92    }).navGrid(
93      '#pager_categories',
94      {edit: true, add: true, del: true, search: true},
95      editOptions,
96      addOptions,
97      delOptions,
98      searchOptions
99  );
100});

Source: tree_grid_categories.js

var URL = "categories"
$(function() {

  $.extend($.jgrid.edit, {
      mtype: 'PUT'
    });
  $.extend($.jgrid.add, {
      mtype: 'POST'
    });
  $.extend($.jgrid.del, {
      mtype: 'DELETE'
    });

  function serializePostData(postdata) {
    var tmp = {};
    $.extend(tmp, postdata);
    postdata.category = {};
    for(var key in tmp) {
      if (key == "name" || key == "category_id")
        postdata.category[key] = postdata[key];
    }
  }

  var editOptions = {
      onclickSubmit: function(params, postdata) {
        serializePostData(postdata);
        params.url = URL + '/' + postdata.id + ".json";
      },
      closeAfterEdit: true
    };

  var addOptions = {
    mtype: "POST",
    onclickSubmit: function(params, postdata) {
      serializePostData(postdata);
      params.url = URL + ".json";
    },
    closeAfterAdd: true
  };

  var delOptions = {
      onclickSubmit: function(params, postdata) {
        postdata = postdata.toString();

        params.url = URL + '/' + postdata + ".json";
      }
    };

  var searchOptions = {
    onclickSubmit: function(params, postdata) {
      params.url = URL + '/' + postdata + ".json";
    },
    multipleSearch: true,
    showQuery: true
  }

  $("#tree_grid_categories").jqGrid({
      treeGrid: true,
      url: URL + ".json",
      editurl: URL,
      datatype: 'json',
      mtype: 'GET',
      treeGridModel: "adjacency",
      // loadonce: true,
      ExpandColClick: true,
      width: "250",
      height: "auto",
      ExpandColumn : 'name',
      colModel: [
        {name:'id', index:'id', hidden: true},
        {name:'name', index:'name', label:'Name', editrules: {required: true}, editable: true, autowidth: true},
        {
          name:'category_id',
          index:'category_id',
          hidden: true,
          label:'Parent category',
          edittype: "select",
          editrules: {edithidden: true},
          editoptions: {dataUrl: "categories.js"},
          editable: true,
          autowidth: true
        }
      ],
      pager: '#pager_categories',
      onSelectRow: function(row_id) {
        node_id = $("#tree_grid_categories").getCell(row_id, "id");
        $.get("products.js", {"nodeid": node_id}, function(data) {
          $("#table_products").html(data);
        }, "html");
      },
      caption: 'Categories'
    }).navGrid(
      '#pager_categories',
      {edit: true, add: true, del: true, search: true},
      editOptions,
      addOptions,
      delOptions,
      searchOptions
  );
});

1{
2	"translatorID": "88e11bcb-464d-4b6d-a446-8994e3b865c9",
3	"translatorType": 4,
4	"label": "Web of Science",
5	"creator": "Philipp Zumstein",
6	"target": "^https?://([^/]+\\.)?webofknowledge\\.com/",
7	"minVersion": "3.0",
8	"maxVersion": null,
9	"priority": 100,
10	"inRepository": true,
11	"browserSupport": "gcsib",
12	"lastUpdated": "2015-03-19 18:25:00"
13}
14
15/*
16	***** BEGIN LICENSE BLOCK *****
17
18	Copyright © 2015 Philipp Zumstein
19
20	This file is part of Zotero.
21
22	Zotero is free software: you can redistribute it and/or modify
23	it under the terms of the GNU Affero General Public License as published by
24	the Free Software Foundation, either version 3 of the License, or
25	(at your option) any later version.
26
27	Zotero is distributed in the hope that it will be useful,
28	but WITHOUT ANY WARRANTY; without even the implied warranty of
29	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30	GNU Affero General Public License for more details.
31
32	You should have received a copy of the GNU Affero General Public License
33	along with Zotero. If not, see <http://www.gnu.org/licenses/>.
34
35	***** END LICENSE BLOCK *****
36*/
37
38function detectWeb(doc, url) {
39	if ( (url.indexOf("full_record.do") !== -1
40			|| url.indexOf("InboundService.do") != -1)
41		&& getSingleItemId(doc)
42	) {
43		return "journalArticle";
44	} else if (((doc.title.indexOf(" Results") !== -1) 
45		|| url.indexOf("search_mode=") !== -1)
46		&& getRecords(doc).length) {
47		return "multiple";
48	}
49}
50
51function getRecords(doc) {
52	return ZU.xpath(doc, '//span[@id="records_chunks"]//div[starts-with(@id,"RECORD_")]');
53}
54
55function getSingleItemId(doc) {
56	var form = doc.forms['records_form'];
57	if(form) return (form.elements.namedItem('marked_list_candidates') || {}).value;
58
59	return false;
60}
61
62function doWeb(doc, url) {
63	var ids = new Array();
64	if (detectWeb(doc, url) == "multiple") {
65		var items = new Object;
66		var records = getRecords(doc);
67		var recordID, title;
68		for(var i=0, n=records.length; i<n; i++) {
69			recordID = ZU.xpathText(records[i], './/input[@name="marked_list_candidates"]/@value');
70			title = ZU.xpathText(records[i], '(.//div[@class="search-results-content"]//a)[1]');
71			if(!title || !recordID) continue;
72			
73			items[recordID] = title.trim();
74		}
75		Zotero.selectItems(items, function (items) {
76			if(!items) return true;
77
78			var ids = [];
79			for(var i in items) {
80				ids.push(i);
81			}
82			fetchIds(ids, doc);
83		});
84	} else {
85		fetchIds([getSingleItemId(doc)], doc);
86	}
87}
88
89function getHiddenValues(form) {
90	var inputs = form.elements;
91	var values = {};
92	var node;
93	for(var i=0; node = inputs.item(i); i++) {
94		if(node.type == 'hidden') {
95			values[node.name] = node.value;
96		}
97	}
98	return values;
99}
100
101function serializePostData(data) {
102	var str = '';
103	for(var i in data) {
104		str += '&' + encodeURIComponent(i) + '='
105			+ encodeURIComponent(data[i]).replace(/%20/g, "+");
106	}
107	return str.substr(1);
108}
109
110function getOutputForm(doc) {
111	return doc.forms['output_form'] || doc.forms['records_form'] || doc.forms['summary_records_form'];
112}
113
114function importISIRecord(text) {
115	Z.debug(text);
116	var importer = Zotero.loadTranslator("import");
117	importer.setTranslator("594ebe3c-90a0-4830-83bc-9502825a6810");
118	importer.setString(text);
119	importer.setHandler('itemDone', function(obj, item) {
120		if(item.title.toUpperCase() == item.title) {
121			item.title = ZU.capitalizeTitle(item.title, true);
122		}
123		
124		var creator;
125		for(var i=0, n=item.creators.length; i<n; i++) {
126			creator = item.creators[i];
127			if(creator.firstName.toUpperCase() == creator.firstName) {
128				creator.firstName = ZU.capitalizeTitle(creator.firstName, true);
129			}
130			if(creator.lastName.toUpperCase() == creator.lastName) {
131				creator.lastName = ZU.capitalizeTitle(creator.lastName, true);
132			}
133		}
134		item.complete();
135	});
136	importer.translate();
137}
138
139function fetchIds(ids, doc) {
140	var outputForm = getOutputForm(doc);
141	var postData = getHiddenValues(outputForm);
142	var filters = 'USAGEIND RESEARCHERID ACCESSION_NUM FUNDING SUBJECT_CATEGORY '
143		+ 'JCR_CATEGORY LANG IDS PAGEC SABBR CITREFC ISSN PUBINFO KEYWORDS '
144		+ 'CITTIMES ADDRS CONFERENCE_SPONSORS DOCTYPE ABSTRACT CONFERENCE_INFO '
145		+ 'SOURCE TITLE AUTHORS '
146		//additional fields from INSPEC
147		+ 'ADDRESS AUTHORS_EDITORS AUTHORSIDENTIFIERS CLASSIFICATION_CODES '
148		+ 'CONFERENCE_SPONSORS DESCRIPTORS IDENTIFYING_CODES IMAGES '
149		+ 'INVENTORS_ASSIGNEES IPC NUM_OF_REF PATENT_INFO SPONSORS TRANSLATORS '
150		+ 'TREATMENT UNCONTROLLED_TERMS';
151	postData['value(record_select_type)'] = 'selrecords';
152	postData['markFrom'] = '';
153	postData['markTo'] = '';
154	postData['fields_selection'] = filters;
155	postData['filters'] = filters;
156	postData['save_options'] = 'othersoftware';
157	postData['format'] = 'saveToRef';
158
159	//add selected items
160	var selectedIds = ids.join(';');
161	postData['selectedIds'] = selectedIds;
162
163	var postUrl = outputForm.action;
164	Z.debug("Posting to " + postUrl);
165	/**
166	 * Note that when using the form on the page, the request ends up redirecting
167	 * to ets.webofknowledge.com which makes it cross-origin. Somehow, this POST
168	 * avoids the redirect, so things just work, but if the behavior changes in
169	 * the future, it would break scraping on IE/bookmarklet and Safari
170	 */
171	ZU.doPost(postUrl, serializePostData(postData), function (text) {
172		//check if there's an intermediate page
173		if(text.indexOf('FN ') === 0) {
174			importISIRecord(text);
175			return;
176		}
177		
178		//otherwise we have an intermediate page (maybe... it just kind of went away one day)
179		//everything it mostly the same as above except for a few fields
180		var postData2 = {}
181		postData2['locale'] = postData['locale'];
182		postData2['colName'] = postData['colName'];
183		postData2['sortBy'] = postData['sortBy'];
184		postData2['SID'] = postData['SID'];
185		postData2['filters'] = postData['filters'];
186		postData2['fileOpt'] = 'fieldtagged';
187		postData2['action'] = 'saveDataToRef';
188		postData2['product'] = 'UA';
189		postData2['numRecords'] = ids.length;
190		postData2['numRecsToRetrieve'] = 500;
191		
192		var qid = text.match(/<input[^>]+name=(['"]?)qid\1[\s\/][^>]*/);
193		if(qid) qid = qid[0].match(/value=['"]?(\d+)/);
194		if(qid) {
195			qid = qid[1];
196		} else {
197			qid = postData['qid']*1+1;	//this can be wrong if pages are refreshed
198			Z.debug("Could not find qid on page. Using 1 + previous qid: " + qid);
199			text = text.replace(/\s*[\r\n]\s*/g, '\n');	//trim out the extra newlines
200			var forms = text.match(/<form[\s\S]+?<\/form>/ig);
201			if(forms) {
202				Z.debug("Page contained the following forms:");
203				Z.debug(forms.join('\n==============================\n'));
204			} else {
205				Z.debug("Could not find any forms on the page. Here's the whole HTML");
206				Z.debug(text);
207			}
208		}
209		postData2['qid'] = qid;
210		
211		var postUrl2 = 'http://ets.webofknowledge.com/ETS/saveDataToRef.do';	//Zotero should take care of proxies
212		ZU.doPost(postUrl2, serializePostData(postData2), function(text) {
213			importISIRecord(text);
214		}, { 'Referer': postUrl });
215
216	}, { 'Referer': doc.location.href });
217}

Source: Web of Science.js

{
	"translatorID": "88e11bcb-464d-4b6d-a446-8994e3b865c9",
	"translatorType": 4,
	"label": "Web of Science",
	"creator": "Philipp Zumstein",
	"target": "^https?://([^/]+\\.)?webofknowledge\\.com/",
	"minVersion": "3.0",
	"maxVersion": null,
	"priority": 100,
	"inRepository": true,
	"browserSupport": "gcsib",
	"lastUpdated": "2015-03-19 18:25:00"
}

/*
	***** BEGIN LICENSE BLOCK *****

	Copyright © 2015 Philipp Zumstein

	This file is part of Zotero.

	Zotero is free software: you can redistribute it and/or modify
	it under the terms of the GNU Affero General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	Zotero is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU Affero General Public License for more details.

	You should have received a copy of the GNU Affero General Public License
	along with Zotero. If not, see <http://www.gnu.org/licenses/>.

	***** END LICENSE BLOCK *****
*/

function detectWeb(doc, url) {
	if ( (url.indexOf("full_record.do") !== -1
			|| url.indexOf("InboundService.do") != -1)
		&& getSingleItemId(doc)
	) {
		return "journalArticle";
	} else if (((doc.title.indexOf(" Results") !== -1) 
		|| url.indexOf("search_mode=") !== -1)
		&& getRecords(doc).length) {
		return "multiple";
	}
}

function getRecords(doc) {
	return ZU.xpath(doc, '//span[@id="records_chunks"]//div[starts-with(@id,"RECORD_")]');
}

function getSingleItemId(doc) {
	var form = doc.forms['records_form'];
	if(form) return (form.elements.namedItem('marked_list_candidates') || {}).value;

	return false;
}

function doWeb(doc, url) {
	var ids = new Array();
	if (detectWeb(doc, url) == "multiple") {
		var items = new Object;
		var records = getRecords(doc);
		var recordID, title;
		for(var i=0, n=records.length; i<n; i++) {
			recordID = ZU.xpathText(records[i], './/input[@name="marked_list_candidates"]/@value');
			title = ZU.xpathText(records[i], '(.//div[@class="search-results-content"]//a)[1]');
			if(!title || !recordID) continue;
			
			items[recordID] = title.trim();
		}
		Zotero.selectItems(items, function (items) {
			if(!items) return true;

			var ids = [];
			for(var i in items) {
				ids.push(i);
			}
			fetchIds(ids, doc);
		});
	} else {
		fetchIds([getSingleItemId(doc)], doc);
	}
}

function getHiddenValues(form) {
	var inputs = form.elements;
	var values = {};
	var node;
	for(var i=0; node = inputs.item(i); i++) {
		if(node.type == 'hidden') {
			values[node.name] = node.value;
		}
	}
	return values;
}

function serializePostData(data) {
	var str = '';
	for(var i in data) {
		str += '&' + encodeURIComponent(i) + '='
			+ encodeURIComponent(data[i]).replace(/%20/g, "+");
	}
	return str.substr(1);
}

function getOutputForm(doc) {
	return doc.forms['output_form'] || doc.forms['records_form'] || doc.forms['summary_records_form'];
}

function importISIRecord(text) {
	Z.debug(text);
	var importer = Zotero.loadTranslator("import");
	importer.setTranslator("594ebe3c-90a0-4830-83bc-9502825a6810");
	importer.setString(text);
	importer.setHandler('itemDone', function(obj, item) {
		if(item.title.toUpperCase() == item.title) {
			item.title = ZU.capitalizeTitle(item.title, true);
		}
		
		var creator;
		for(var i=0, n=item.creators.length; i<n; i++) {
			creator = item.creators[i];
			if(creator.firstName.toUpperCase() == creator.firstName) {
				creator.firstName = ZU.capitalizeTitle(creator.firstName, true);
			}
			if(creator.lastName.toUpperCase() == creator.lastName) {
				creator.lastName = ZU.capitalizeTitle(creator.lastName, true);
			}
		}
		item.complete();
	});
	importer.translate();
}

function fetchIds(ids, doc) {
	var outputForm = getOutputForm(doc);
	var postData = getHiddenValues(outputForm);
	var filters = 'USAGEIND RESEARCHERID ACCESSION_NUM FUNDING SUBJECT_CATEGORY '
		+ 'JCR_CATEGORY LANG IDS PAGEC SABBR CITREFC ISSN PUBINFO KEYWORDS '
		+ 'CITTIMES ADDRS CONFERENCE_SPONSORS DOCTYPE ABSTRACT CONFERENCE_INFO '
		+ 'SOURCE TITLE AUTHORS '
		//additional fields from INSPEC
		+ 'ADDRESS AUTHORS_EDITORS AUTHORSIDENTIFIERS CLASSIFICATION_CODES '
		+ 'CONFERENCE_SPONSORS DESCRIPTORS IDENTIFYING_CODES IMAGES '
		+ 'INVENTORS_ASSIGNEES IPC NUM_OF_REF PATENT_INFO SPONSORS TRANSLATORS '
		+ 'TREATMENT UNCONTROLLED_TERMS';
	postData['value(record_select_type)'] = 'selrecords';
	postData['markFrom'] = '';
	postData['markTo'] = '';
	postData['fields_selection'] = filters;
	postData['filters'] = filters;
	postData['save_options'] = 'othersoftware';
	postData['format'] = 'saveToRef';

	//add selected items
	var selectedIds = ids.join(';');
	postData['selectedIds'] = selectedIds;

	var postUrl = outputForm.action;
	Z.debug("Posting to " + postUrl);
	/**
	 * Note that when using the form on the page, the request ends up redirecting
	 * to ets.webofknowledge.com which makes it cross-origin. Somehow, this POST
	 * avoids the redirect, so things just work, but if the behavior changes in
	 * the future, it would break scraping on IE/bookmarklet and Safari
	 */
	ZU.doPost(postUrl, serializePostData(postData), function (text) {
		//check if there's an intermediate page
		if(text.indexOf('FN ') === 0) {
			importISIRecord(text);
			return;
		}
		
		//otherwise we have an intermediate page (maybe... it just kind of went away one day)
		//everything it mostly the same as above except for a few fields
		var postData2 = {}
		postData2['locale'] = postData['locale'];
		postData2['colName'] = postData['colName'];
		postData2['sortBy'] = postData['sortBy'];
		postData2['SID'] = postData['SID'];
		postData2['filters'] = postData['filters'];
		postData2['fileOpt'] = 'fieldtagged';
		postData2['action'] = 'saveDataToRef';
		postData2['product'] = 'UA';
		postData2['numRecords'] = ids.length;
		postData2['numRecsToRetrieve'] = 500;
		
		var qid = text.match(/<input[^>]+name=(['"]?)qid\1[\s\/][^>]*/);
		if(qid) qid = qid[0].match(/value=['"]?(\d+)/);
		if(qid) {
			qid = qid[1];
		} else {
			qid = postData['qid']*1+1;	//this can be wrong if pages are refreshed
			Z.debug("Could not find qid on page. Using 1 + previous qid: " + qid);
			text = text.replace(/\s*[\r\n]\s*/g, '\n');	//trim out the extra newlines
			var forms = text.match(/<form[\s\S]+?<\/form>/ig);
			if(forms) {
				Z.debug("Page contained the following forms:");
				Z.debug(forms.join('\n==============================\n'));
			} else {
				Z.debug("Could not find any forms on the page. Here's the whole HTML");
				Z.debug(text);
			}
		}
		postData2['qid'] = qid;
		
		var postUrl2 = 'http://ets.webofknowledge.com/ETS/saveDataToRef.do';	//Zotero should take care of proxies
		ZU.doPost(postUrl2, serializePostData(postData2), function(text) {
			importISIRecord(text);
		}, { 'Referer': postUrl });

	}, { 'Referer': doc.location.href });
}