Create new list item

        :param new_data: dictionary of {'col_name': col_value}

        :rtype: SharepointListItem
769168
def create_list_item(self, new_data):
        

        url = self.build_url(self._endpoints.get('get_items'))

        response = self.con.post(url, {'fields': new_data})
        if not response:
            return False

        data = response.json()

        return self.list_item_constructor(parent=self, **{self._cloud_data_key: data})
846800
def create_data_item_from_data_and_metadata(self, data_and_metadata: DataAndMetadata.DataAndMetadata, title: str=None) -> DataItem:
        
        data_item = DataItemModule.new_data_item(data_and_metadata)
        if title is not None:
            data_item.title = title
        self.__document_controller.document_model.append_data_item(data_item)
        return DataItem(data_item)
124488
def new_item(self, hash_key, range_key=None, attrs=None):
        
        return Item(self, hash_key, range_key, attrs)
558255
def append(self, item):
        
        try:
            self._data[self._position] = item
        except IndexError:
            self._grow()
            self._data[self._position] = item
        self._position += 1
        return self
926203
def create_item(opts={})
      opts = check_opts(CREATE_ITEM_OPTS, opts)
      
      items = opts[:items].compact if opts[:items]
      raise "no items!" if items.empty?

      attrs = {}
      attrs[:message_disposition] = opts[:message_disposition] if opts[:message_disposition]
      attrs[:send_meeting_invitations] = opts[:send_meeting_invitations] if opts[:send_meeting_invitations]

      r = with_error_check(self, :create_item_response, :response_messages, :create_item_response_message) do
        savon_client.request(:wsdl, "CreateItem", attrs) do
          http.headers["SOAPAction"] = "\"#{SCHEMA_MESSAGES}/CreateItem\"" # required by EWS 2007
          soap.namespaces["xmlns:t"]=SCHEMA_TYPES

          xml = Builder::XmlMarkup.new

          xml.wsdl :Items do
            items.each do |item|
              xml << Util.rsxml_to_xml(item)
            end
          end

          soap.body = xml.target!
        end
      end
      r
    end
967091
def nested_insert(self, item_list):
        
        if len(item_list) == 1:
            self[item_list[0]] = LIVVDict()
        elif len(item_list) > 1:
            if item_list[0] not in self:
                self[item_list[0]] = LIVVDict()
            self[item_list[0]].nested_insert(item_list[1:])
1059414
def add(self, data):
        
        for host in data:
            for key in data[host]:
                if not data[host][key] == []:
                    self.add_item(host, key, data[host][key])
932626
def add_data(self, data):  # add append option later
        
        df = pd.DataFrame(data)
        name, dtype = self.get_singular_and_plural_dtype(self.dtype)
        if name in df.columns:
            df.index = df[name]
        df.index.name = name + " name"
        self.df = df
1198769
def snapshot_data_item(self, data_item: DataItem) -> DataItem:
        
        data_item = data_item._data_item.snapshot()
        self.__document_model.append_data_item(data_item)
        return DataItem(data_item)
643664
def append(self, item):
        
        self.check_insertion(item)

        self.real_list.append(item)
        self._items |= {item}
662769
def create_new_item(*args)
      if block_given?
        new_item = yield(*args)
      else
        new_item = create(*args)
      end

      transform_item(new_item)
    end
723574
def col_append(self, col_key, value_list):
        
        if col_key in self._col_keys:
            raise KeyError('Key %s already exists col keys.' % col_key)
        if not isinstance(value_list, (tuple, list)):
            value_list = [value_list] * len(self._row_keys)
        if not len(value_list) == len(self._row_keys):
            raise ValueError('Length of data to set does not meet expected col length of %i' % len(self._row_keys))
        self._col_keys.append(col_key)
        for r, v in zip(self._row_keys, value_list):
            self[r, col_key] = v
992632
function updateListItem(itemMetadata, customFileMetadata) {
            // Define the list item changes. Use the FileLeafRef property to change the display name. 
            // Assemble the file update metadata 
            var metadata = {
                __metadata: {
                    type: itemMetadata.type
                },
                FileLeafRef: fileuniquename,
                Title: filedisplayname
            };

            // Add the custom metadata fields for this file to the metadata object
            if (typeof(customFileMetadata) === "object") $(metadata).extend(metadata, customFileMetadata);
            
            // Send the request and return the promise.
            // This call does not return response content from the server.
            var body = JSON.stringify(metadata);
            return $http.post(itemMetadata.uri, body, {
                headers: {
                    "X-RequestDigest": $("#__REQUESTDIGEST").val(),
                    "content-type": "application/json;odata=verbose",
                    "content-length": body.length,
                    "IF-MATCH": "*",
                    "X-HTTP-Method": "MERGE"
                }
            });
        }
943094
def new(self, **dict):
        ''''''
        if not self._item_new_path:
            raise AttributeError('new is not available for %s' % self._item_name)

        # Remap various tag to tag_id
        for tag in self._object._remap_to_id:
            self._object._remap_tag_to_tag_id(tag, dict)

        target = self._item_new_path
        payload = json.dumps({self._item_type:dict})
        json_data = self._redmine.post(target, payload)
        data = self._redmine.unwrap_json(self._item_type, json_data)
        data['_source_path'] = target
        return self._objectify(data=data)
723245
def add_item(self, sqla_col_type, item, key_specific=None):
        
        if key_specific is not None:
            self.setdefault(key_specific, {})[sqla_col_type] = item
        else:
            self[sqla_col_type] = item
499872
def _add_new_items(self, config, seen):
        ''''''
        for (key, value) in self.items():
            if key not in seen:
                self._set_value(config, key, value)
458694
def fill_list(self, list, input_list):
        
        for name in input_list:
            # print(index, loaded_item, loaded_item_settings)
            item = QtGui.QStandardItem(name)
            item.setSelectable(True)
            item.setEditable(False)

            list.model().appendRow(item)