Creates a record by posting to airtable
433305
def create(record)
      result = self.class.post(worksheet_url,
        :body => { "fields" => record.fields }.to_json,
        :headers => { "Content-type" => "application/json" }).parsed_response

      check_and_raise_error(result)

      record.override_attributes!(result_attributes(result))
      record
    end
639992
@Override
    public void processPut(Record record, String tabName,
            String famName, String quaName) {
	logger.debug("NATIVE Begin processPut(" + record + ", " + tabName + ")");
        HTable hTable = getTable(tabName);
        try {
            Put op = createPut(record, tabName, famName, quaName);
            hTable.put(op);
        } catch (IOException e) {
            logger.error("Error while attempting to perform operations at HBaseDataTransactions.");
            logger.error(e.getMessage());
        }
    }
213219
def emit(self, record):
        

        if bool(self.store_only):
            do_not_store = True
            for extra in self.store_only:
                if bool(getattr(record, extra, None)):
                    do_not_store = False
                    break

            if do_not_store:
                return

        self.db = sqlite3.connect(self.filename)

        self.db.execute(
            """
                INSERT INTO log(
                    log_level,
                    log_level_name,

                    name,
                    message,
                    args,

                    module,
                    func_name,
                    line_no,
                    filename,

                    exception,
                    process,
                    thread,
                    thread_name,

                    siteconfig
                )
                VALUES(
                    ?,?,
                    ?,?,?,
                    ?,?,?,?,
                    ?,?,?,?,
                    ?
                );""",
            (
                record.levelno,
                record.levelname,

                record.name,
                record.msg,
                json.dumps(record.args, cls=OrderedEncoder),

                record.module,
                record.funcName,
                record.lineno,
                os.path.abspath(record.filename),

                record.exc_text,
                record.process,
                record.thread,
                record.threadName,

                getattr(record, 'siteconfig', None),
            )
        )
        self.db.commit()
        self.db.close()
151267
def _create_record(attribute_names = self.attribute_names)
      attribute_names = attributes_for_create(attribute_names)

      new_id = self.class._insert_record(
        attributes_with_values(attribute_names)
      )

      self.id ||= new_id if @primary_key

      @new_record = false

      yield(self) if block_given?

      id
    end
930382
function Record(value, actualIndex) {
    var _label = '';

    this.labeled = function(label) {
        _label = label;
    };

    this.label = function() {
        return _label;
    };

    this.toString = function() {
        return value;
    };

    this.at = function(index) {
        if(actualIndex !== index) {
            throw new Error([
                'Actual index was:',
                actualIndex,
                ', expected was:',
                index
            ].join(' '));
        }
    };
}
477222
public Record openMainRecord()
    {
        Record record = null;
        if (this.getProperty(DBParams.APPLET) != null)
        	return null;	// Ignore params if I want the applet html displayed
        String strParamRecord = this.getProperty(DBParams.RECORD);      // Display record
        if ((strParamRecord != null) && (strParamRecord.length() > 0))
            record = Record.makeRecordFromClassName(strParamRecord, this);
        return record;
    }
986029
def create
      return false unless new_record?
      run_callbacks :save do
        run_callbacks :create do
          httparty = self.class.post(self.class.index_path, request_options.merge(:body => to_json))
          handle_save_response(httparty)
        end
      end
    end
1188636
def _create_record(name, field_defs, step_name, inputs, unlist, file_vs, std_vs, parallel):
    
    if field_defs:
        fields = []
        inherit = []
        inherit_all = False
        inherit_exclude = []
        for fdef in field_defs:
            if not fdef.get("type"):
                if fdef["id"] == "inherit":
                    inherit_all = True
                    inherit_exclude = fdef.get("exclude", [])
                else:
                    inherit.append(fdef["id"])
            else:
                cur = {"name": _get_string_vid(fdef["id"]),
                       "type": fdef["type"]}
                fields.append(_add_secondary_to_rec_field(fdef, cur))
        if inherit_all:
            fields.extend(_infer_record_outputs(inputs, unlist, file_vs, std_vs, parallel, exclude=inherit_exclude))
        elif inherit:
            fields.extend(_infer_record_outputs(inputs, unlist, file_vs, std_vs, parallel, inherit))
    else:
        fields = _infer_record_outputs(inputs, unlist, file_vs, std_vs, parallel)
    out = {"id": "%s/%s" % (step_name, name),
           "type": {"name": name,
                    "type": "record",
                    "fields": fields}}
    if parallel in ["batch-single", "multi-batch"]:
        out = _nest_variable(out)
    return out
1261482
def create_record(self, dns_type, name, content, **kwargs):
        
        data = {
            'type': dns_type,
            'name': name,
            'content': content
        }
        if kwargs.get('ttl') and kwargs['ttl'] != 1:
            data['ttl'] = kwargs['ttl']
        if kwargs.get('proxied') is True:
            data['proxied'] = True
        else:
            data['proxied'] = False
        content = self.request(
            self.api_url + self.zone['id'] + '/dns_records',
            'post',
            data=data
        )
        print('DNS record successfully created')
        return content['result']
348429
def create_post(post_uid, post_data):
        '''
        
        '''
        title = post_data['title'].strip()
        if len(title) < 2:
            return False


        cur_rec = MPost.get_by_uid(post_uid)
        if cur_rec:
            return False

        entry = TabPost.create(
            title=title,
            date=datetime.now(),
            cnt_md=tornado.escape.xhtml_escape(post_data['cnt_md'].strip()),
            cnt_html=tools.markdown2html(post_data['cnt_md']),
            uid=post_uid,
            time_create=post_data.get('time_create', tools.timestamp()),
            time_update=post_data.get('time_update', tools.timestamp()),
            user_name=post_data['user_name'],
            view_count=post_data['view_count'] if 'view_count' in post_data else 1,
            logo=post_data['logo'],
            memo=post_data['memo'] if 'memo' in post_data else '',
            order=post_data['order'] if 'order' in post_data else '',
            keywords=post_data['keywords'] if 'keywords' in post_data else '',
            extinfo=post_data['extinfo'] if 'extinfo' in post_data else {},
            kind=post_data['kind'] if 'kind' in post_data else '1',
            valid=post_data.get('valid', 1)
        )
        return entry.uid
256534
function inputRecord (type, record) {
  const clone = {};
  const recordTypes = this.recordTypes;
  const primaryKey = this.keys.primary;
  const isArrayKey = this.keys.isArray;
  const generateId = this.options.generateId;
  const fields = recordTypes[type];

  // ID business.
  const id = record[primaryKey];
  clone[idKey] = id ? id : generateId(type);

  for (const field in record) {
    if (field === primaryKey) continue;
    clone[field] = record[field];
  }

  for (const field of Object.getOwnPropertyNames(fields))
    if (!(field in record))
      clone[field] = fields[field][isArrayKey] ? [] : null;

  return clone;
}
191935
function create(dataID: DataID, typeName: string): Record {
  // See perf note above for why we aren't using computed property access.
  const record = {};
  record[ID_KEY] = dataID;
  record[TYPENAME_KEY] = typeName;
  return record;
}
651952
def setRecord(self, record):
        
        self._record = record
        if record is not None:
            self.loadValues(record.recordValues(autoInflate=True))
        else:
            self.loadValues({})
191267
def create
      @record = Post.new(page_params)
      @record.additional_data(params[:additional_data])

      respond_to do |format|

        if @record.save
          format.html { redirect_to admin_pages_path, notice: I18n.t("controllers.admin.pages.create.flash.success") }
        else
          format.html {
            # add breadcrumb and set title
            add_breadcrumb I18n.t("controllers.admin.pages.new.breadcrumb")
            @action = 'create'
            flash[:error] = I18n.t('generic.validation.no_passed')
            render action: "new"
          }
        end

      end

    end
129613
def create_record(self, domain, name, _type, data, params=None):
        ''' 
        '''
        params = update_params(params, {
            'domain': domain,
            'name': name,
            'type': _type,
            'data': data
        })
        return self.request('/v1/dns/create_record', params, 'POST')
542013
def _add_record(table, data, buffer_size):
    
    fields = table.fields
    # remove any keys that aren't relation fields
    for invalid_key in set(data).difference([f.name for f in fields]):
        del data[invalid_key]
    table.append(Record.from_dict(fields, data))
    # write if requested and possible
    if buffer_size is not None and table.is_attached():
        # for now there isn't a public method to get the number of new
        # records, so use private members
        if (len(table) - 1) - table._last_synced_index > buffer_size:
            table.commit()
160612
def _create_record(self, rtype, name, content):
        """"""
        return self._change_record_sets('CREATE', rtype, name, content)