query
stringlengths 7
9.55k
| document
stringlengths 10
363k
| metadata
dict | negatives
sequencelengths 0
101
| negative_scores
sequencelengths 0
101
| document_score
stringlengths 3
10
| document_rank
stringclasses 102
values |
|---|---|---|---|---|---|---|
Merge the local results into the ancestor result hash. | def render!
result
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merged_result; end",
"def merged_result\n # conceptually this is just doing `merge_results(resultset_path)`\n # it's more involved to make syre `synchronize_resultset` is only used around reading\n resultset_hash = read_resultset\n command_names, coverage = merge_valid_results(resultset_hash)\n\n create_result(command_names, coverage)\n end",
"def merge_resultsets(result1, result2); end",
"def merge_resultsets(result1, result2); end",
"def merge_results_from_worker(results)\n @mutex.synchronize do\n results.each do |r|\n new_props = @job_inst.collector_combine_block(r, @n, @val)\n @n = new_props[:n]\n @val = new_props[:val]\n end\n end\n end",
"def merge(base_hash, derived_hash); end",
"def merge_results(*results); end",
"def merge_results(*results); end",
"def merge_results(*results); end",
"def merge(other_hash); end",
"def deep_merge_hashes(master_hash, other_hash); end",
"def merge(base_hash, derived_hash)\n resolver.merge(base_hash, derived_hash)\n end",
"def _rsits_combined_hash\n\t\tself.class.instance_variable_get(\n\t\t\t:@parent_groups # For each item in @parent_groups\n\t\t).reduce( {} ) do |final, pg|\n\t\t\tfinal.merge pg._rsits # Merge the _rsits hash into 'final'\n\t\tend\n\tend",
"def merge(hash); end",
"def merge(hash); end",
"def merge(hash); end",
"def merge_results( results )\n info = {}\n formatted = {}\n\n results << self.results\n results.each do |plugins|\n plugins.each do |name, res|\n next if !res\n\n formatted[name] ||= []\n formatted[name] << res[:results]\n\n info[name] = res.reject{ |k, v| k == :results } if !info[name]\n end\n end\n\n merged = {}\n formatted.each do |plugin, c_results|\n if !self[plugin].distributable?\n res = c_results[0]\n else\n res = self[plugin].merge( c_results )\n end\n merged[plugin] = info[plugin].merge( :results => res )\n end\n\n self.results = merged\n end",
"def merge(base_hash, derived_hash, **opts); end",
"def manifest_merge\n UI::status(\"resolving manifests\")\n UI::debug(\" overwrite #{overwrite?} partial #{filter}\")\n UI::debug(\" ancestor #{ancestor} local #{local} remote #{remote}\")\n \n copy = calculate_copies\n copied_files = Hash.with_keys(copy.values)\n \n # Compare manifests\n working_changeset.each do |file, node|\n update_local_file file, node, copy, copied_files\n end\n \n remote.each do |file, node|\n update_remote_file file, node, copy, copied_files\n end\n end",
"def merge(*other_hashes, &blk); end",
"def deep_merge(*other_hashes, &blk); end",
"def combined_hash\n y = if @process_global\n normalize(global_yaml).rmerge(normalize(yaml))\n else\n normalize(yaml)\n end\n @process_local ? y.rmerge(normalize(local_yaml)) : y\n end",
"def merge!(*other_hashes, &blk); end",
"def deep_merge!(*other_hashes, &blk); end",
"def merge; end",
"def deep_merge_hashes!(target, overwrite); end",
"def merge hash = {}\n original.merge(hash)\n end",
"def _deep_merge(hash, other_hash); end",
"def results_hash\n hash = {:updated => [],\n :merged => [],\n :removed => [],\n :unresolved => []}\n\n class << hash\n def success?; self[:unresolved].empty?; end\n end\n hash\n end",
"def hash_merger(query_vals)#another hash that is nested)\n merged_hash = Hash.new\n # for each key_val_set\n # check if key exists in merged_hash\n # if not - add in the value\n # if yes - key into merged_hash with key, and check next key\n\n query_vals.each do |keys, val|\n current = merged_hash\n keys.each_with_index do |key,i|\n if i == keys.length - 1\n current[key] = val\n else\n current[key] ||= {}\n current = current[key]\n end\n end\n end\n merged_hash\n end",
"def deep_merge(source, hash); end",
"def deep_merge(source, hash); end",
"def joined_results\n if conflict?\n if @conflict_handler\n @conflict_handler[results]\n else\n results\n end\n else\n first, rest = results.first, results[1..-1]\n rest.reduce(first) { |rs, r| rs.combine(r) }.apply(@join_function).result\n end\n end",
"def merge!(other_hash); end",
"def deep_merge(other_hash, &blk)\n dup.deep_update(other_hash, &blk)\n end",
"def internal_deep_merge!(source_hash, specialized_hash)\n\t\t\tspecialized_hash.each_pair do |rkey, rval|\n\t\t\t\tif source_hash.has_key?(rkey) then\n\t\t\t\t\tif rval.is_a?(Hash) and source_hash[rkey].is_a?(Hash) then\n\t\t\t\t\t\tinternal_deep_merge!(source_hash[rkey], rval)\n\t\t\t\t\telsif rval == source_hash[rkey] then\n\t\t\t\t\telse\n\t\t\t\t\t\tsource_hash[rkey] = rval\n\t\t\t\t\tend\n\t\t\t\telse\n\t\t\t\t\tsource_hash[rkey] = rval\n\t\t\t\tend\n\t\t\tend\n\t\t\tsource_hash\n\t\tend",
"def deep_merge!(other_hash, &block); end",
"def _rh_merge(result, data)\n return _rh_merge_choose_data(result, data) unless data.is_a?(Hash)\n\n data.each do |key, _value|\n next if [:__struct_changing, :__protected].include?(key)\n\n _do_rh_merge(result, key, data)\n end\n [:__struct_changing, :__protected].each do |key|\n # Refuse merge by default if key data type are different.\n # This assume that the first layer merge has set\n # :__unset as a Hash, and :__protected as an Array.\n\n _do_rh_merge(result, key, data, true) if data.key?(key)\n\n # Remove all control element in arrays\n _rh_remove_control(result[key]) if result.key?(key)\n end\n\n result\n end",
"def shallow_merge(other_hash); end",
"def merge!(hash); end",
"def merge(hash)\n hash.each_value { |v| self << v }\n end",
"def _rh_merge_recursive(result, key, data)\n return false unless [Array, Hash].include?(data.class)\n\n value = data[key]\n return false unless [Array, Hash].include?(value.class) &&\n value.class == result[key].class\n\n if object_id == result.object_id\n result[key].rh_merge!(value)\n else\n result[key] = result[key].rh_merge(value)\n end\n\n true\n end",
"def merge!; end",
"def merge(other)\n other.inject(self) { |result, entry| result << entry }\n end",
"def pull_out(parent_hash)\n return parent_hash[\"results\"]\n rescue\n return []\n end",
"def merge_movie_search_results(results)\n results.flatten\n end",
"def to_hash\n @parent_hash.to_hash.merge(self)\n end",
"def result_with_hash(hash)\n b = new_toplevel(hash.keys)\n hash.each_pair do |key, value|\n b.local_variable_set(key, value)\n end\n result(b)\n end",
"def recurse_local\n result = perform_recursion(self[:path])\n return {} unless result\n result.inject({}) do |hash, meta|\n next hash if meta.relative_path == \".\"\n\n hash[meta.relative_path] = newchild(meta.relative_path)\n hash\n end\n end",
"def merge\n a_hash = without_empty_values @a.to_h\n b_hash = without_empty_values @b.to_h\n\n @a.class.new a_hash.merge b_hash\n end",
"def merge(r, equalities_resolved = false)\n if ::ActiveRecord::Relation === r && !equalities_resolved\n if self.table_name != r.table_name\n super(r.visited)\n else\n merge_resolving_duplicate_squeel_equalities(r)\n end\n else\n super(r)\n end\n end",
"def merge(hash_1, hash_2)\n\nend",
"def parents(result=nil)\n if result\n if @parents\n result |= @parents\n else\n\n upstreams.each do |upstream|\n if upstream.job == job\n upstream.parents(result)\n else\n result.add(upstream)\n end\n end\n\n result.to_a\n end\n else\n @parents ||= parents(Set.new)\n end\n end",
"def rh_merge(data)\n _rh_merge(clone, data)\n end",
"def align_all_local\n @results = []\n @proteins.each { |protein|\n @results << align_local(protein)\n }\n @results = @results.sort_by { |evaluated_protein| evaluated_protein.value }\n end",
"def deep_merge!(target, hash); end",
"def deep_merge!(target, hash); end",
"def merge(other); end",
"def global_merge_data\n @global_merge_data\n end",
"def merge_with_parent\n if @template != nil\n return merge_values(@template.values, @values)\n else\n return @values\n end\n end",
"def combine_results(*hashes)\n final_hash = {\n 'http_code_distribution' => {},\n 'latency_distribution' => {}\n }\n to_add = ['errors', 'latency_sum', 'requests']\n to_combine = ['latency_distribution', 'http_code_distribution']\n\n to_add.each do |item|\n final_hash[item] = 0\n end\n\n hashes.each do |this_hash|\n next if this_hash == nil\n to_add.each do |key|\n final_hash[key] += this_hash[key] if this_hash.has_key?(key)\n end\n to_combine.each do |key|\n final_hash[key] = combine_hashes(final_hash[key], this_hash[key])\n end\n end\n return final_hash\nend",
"def merge_result!(key, val)\n if key\n result[key] = massage_value(val)\n else\n result.merge!(massage_value(val))\n end\n end",
"def custom_merge(hash1, hash2)\n fin=hash1.dup\n hash2.each do |ky,val|\n fin[ky]=val\n end\n fin\nend",
"def reverse_merge(other_hash); end",
"def reverse_merge(other_hash); end",
"def deep_hash_merge(query_hash, attribute_hash)\n query_hash.merge(attribute_hash) do |_key, oldval, newval|\n oldval = oldval.to_hash if oldval.respond_to?(:to_hash)\n newval = newval.to_hash if newval.respond_to?(:to_hash)\n oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? deep_hash_merge(oldval, newval) : newval\n end\n end",
"def merge_values(template, cur)\n root = template['root']\n template = template.merge(cur)\n template['root'] = root\n return template\n end",
"def append_json_results(second_wrapper)\n\n primary_result_as_ruby = JSON.parse(self.result)\n second_result_as_ruby = JSON.parse(second_wrapper.result)\n merged_result = primary_result_as_ruby + second_result_as_ruby\n\n # The second request might have an URL to point at even more data, so preserve the 'More' url from that wrapper.\n WAPIResultWrapper.new(meta_status, \"Merged wapi results\", JSON.generate(merged_result), second_wrapper.meta_more)\n\n end",
"def deep_merge(other, &bloc)\n other.keys.inject(dup) do |result, key|\n begin\n case result[key]\n when Hash\n if other[key].is_a?(Hash)\n result[key] = result[key].deep_merge(other[key], &bloc)\n result\n else\n raise MergeConflict\n end\n when nil then result.merge key => other[key]\n else\n raise MergeConflict\n end\n rescue MergeConflict\n if bloc.nil?\n result[key] = other[key]\n else\n result[key] = bloc.call(result, other, key) \n end\n result\n end\n end\n \n end",
"def rh_merge!(data)\n _rh_merge(self, data)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def cache_results\n return unless current_user && !using_defaults\n\n # Do the results contain master_id? If so, get a unique list of master id results\n master_ids = results.map { |r| r['master_id'] }.uniq if field_index('master_id')\n\n # We through other stuff into the search attribute values that are not needed for storing results\n # Just pass over the real key-value pairs that correspond to the configured attributes\n real_search_attr_values = search_attr_values.slice(*search_attributes.keys)\n\n previous_filtering.store_results(report.id, report.name, master_ids, results.count, real_search_attr_values)\n end",
"def merge!(hash)\n hash.each do |k,v|\n @new_info[lookup_key(k)] = v\n end\n self\n end",
"def merge_all\n merge_concurrent(0)\n end",
"def merge!(other)\n @hash.merge!(other.hash)\n end",
"def merge_child_hashes( h1, h2, key )\n h_out = {}\n if h1.has_key?( key )\n if h2.has_key?( key )\n h_out = { key => h1[ key ].merge( h2[ key ] ) }\n else\n h_out = { key => h1[ key ] }\n end\n elsif h2.has_key?( key )\n h_out = { key => h2[ key ] }\n end\n return h_out\nend",
"def merge\n @mergeit.merge_data(@input_files)\n end",
"def smart_merge(parent, child)\n parent.merge(child) do |key, old, new|\n case old\n when Array\n old + new\n when Hash\n smart_merge(old, new)\n else\n new\n end\n end\n end",
"def merge_hash!(hash)\n merge!(self.class.from_hash(hash))\n end",
"def deep_merge!(other_hash = {})\n replace(deep_merge(other_hash))\n end",
"def merge_bidir_tmp(tmp)\n dist = { aai: {}, ani: {} }\n cli[:threads].times do |i|\n cli.advance('Merging:', i + 1, cli[:threads], false)\n file = File.join(tmp, \"#{i}.json\")\n File.open(file, 'r') do |fh|\n metric = nil\n fh.each do |ln|\n qry, row = ln.chomp.split(' ', 2)\n row or raise \"Unexpected format in #{file}:#{$.}\"\n if qry == '#'\n metric = row.to_sym\n else\n raise \"Unrecognized metric: #{metric}\" unless dist[metric]\n JSON.parse(row).each do |sbj, val|\n dist[metric][qry] ||= {}\n if dist[metric][sbj]&.include?(qry)\n dist[metric][sbj].delete(qry) # Already bidirectional\n else\n dist[metric][qry][sbj] = val\n end\n end\n end\n end\n raise \"Incomplete thread dump: #{file}\" unless metric == :end\n end\n end\n cli.say\n\n return dist\n end",
"def deep_merge_hashes(master_hash, other_hash)\n target = master_hash.dup\n\n other_hash.each_key do |key|\n if other_hash[key].is_a? Hash and target[key].is_a? Hash\n target[key] = deep_merge_hashes(target[key], other_hash[key])\n next\n end\n\n target[key] = other_hash[key]\n end\n\n target\n end",
"def deep_merge!(other_hash)\n replace(deep_merge(other_hash))\n end",
"def merge(base_hash, derived_hash, **opts)\n result = base_hash.merge(derived_hash)\n keys_appearing_in_both = base_hash.keys & derived_hash.keys\n keys_appearing_in_both.each do |key|\n if opts[:unset_nil] && derived_hash[key].nil?\n result.delete(key)\n elsif base_hash[key].is_a?(Hash)\n result[key] = merge(base_hash[key], derived_hash[key], **opts)\n elsif should_union?(base_hash, key, opts[:inherit_mode])\n result[key] = base_hash[key] | derived_hash[key]\n elsif opts[:debug]\n warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)\n end\n end\n result\n end",
"def merge(with); end",
"def deep_merge!(other_hash)\n replace(deep_merge(other_hash))\n end",
"def merge(hash_1, hash_2)\n new_hash = Hash.new()\n\n hash_1.each {|key, value| new_hash[key] = value}\n\n hash_2.each {|key, value| new_hash[key] = value}\n new_hash\nend",
"def _deep_merge(original_hash, filtered_hash)\n original_hash.merge(filtered_hash) do |_key, original_item, filtered_item|\n if original_item.is_a?(Hash) && filtered_item.is_a?(Hash)\n _deep_merge(original_item, filtered_item)\n elsif filtered_item == FILTERED_VALUE\n filtered_item\n else\n original_item\n end\n end\n end",
"def merge other_hash\n self.class.new nested_class, to_h.merge((other_hash if other_hash.is_a? Hash) || other_hash.to_h)\n end",
"def merge(other_hash)\n ret = self.class.new.merge!(self)\n ret.merge!(other_hash) if other_hash != self\n return ret\n end",
"def deep_merge!(other_hash)\r\n replace(deep_merge(other_hash))\r\n end",
"def concat_merge original\n {}.tap do |result|\n original.each do |element|\n element.each_pair do |key, value|\n if value.is_a?(Array)\n result[key] ||= []\n result[key].concat value\n merge_if_equals(result[key])\n else\n result[key] = value\n end\n end\n end\n end\n end",
"def merge(other_hash, &block)\n to_h.merge(other_hash, &block).reduce(self.class.new) do |map, pair|\n map[pair.first] = pair.last\n map\n end\n end",
"def merge(other_hash, &block)\n to_h.merge(other_hash, &block).reduce(self.class.new) do |map, pair|\n map[pair.first] = pair.last\n map\n end\n end",
"def results\n @results ||= {}\n end",
"def merge!(other)\n\t\tALL.each do |key|\n\t\t\tincrement(key, other.get(key))\n\t\tend\n\t\tself\n\tend"
] | [
"0.67083436",
"0.6518971",
"0.62164724",
"0.62161964",
"0.6183703",
"0.6104718",
"0.60974944",
"0.60974944",
"0.609749",
"0.6073796",
"0.60690373",
"0.605404",
"0.60513556",
"0.6041792",
"0.6041792",
"0.6041792",
"0.5952141",
"0.58916056",
"0.58490264",
"0.5814436",
"0.5811484",
"0.58075994",
"0.5779429",
"0.57521605",
"0.5741991",
"0.5669063",
"0.56427336",
"0.56347424",
"0.5632509",
"0.56112975",
"0.560464",
"0.560464",
"0.5578938",
"0.5557347",
"0.5516931",
"0.55036986",
"0.54847354",
"0.5474265",
"0.5465432",
"0.5446263",
"0.5442168",
"0.5431902",
"0.5414846",
"0.54087436",
"0.5398839",
"0.538769",
"0.5382467",
"0.5375698",
"0.5370091",
"0.53487366",
"0.53443176",
"0.534078",
"0.5332989",
"0.53226703",
"0.5302533",
"0.5280409",
"0.5280409",
"0.5275972",
"0.52716076",
"0.5265573",
"0.5259711",
"0.5243735",
"0.52351934",
"0.52285993",
"0.52285993",
"0.5222312",
"0.5221745",
"0.5220528",
"0.5218984",
"0.5212999",
"0.5210848",
"0.5210848",
"0.5210848",
"0.5210848",
"0.5210848",
"0.5210848",
"0.5192451",
"0.5184242",
"0.5183333",
"0.5174575",
"0.51719165",
"0.51701796",
"0.51658475",
"0.5164703",
"0.516054",
"0.5152717",
"0.51484114",
"0.5145547",
"0.51384366",
"0.5131276",
"0.5129569",
"0.5126938",
"0.51208895",
"0.51096094",
"0.5106917",
"0.51022553",
"0.51016074",
"0.5101537",
"0.5101537",
"0.5100014",
"0.50976926"
] | 0.0 | -1 |
Return the jsonencoded result hash. | def to_json
MultiJson.encode(result)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_hash\n\n json = {\n :errorCode => @server_id,\n :transactionReceipt => @api_key\n }\n\n if @message_results.length > 0\n e = Array.new\n @message_results.each do |value|\n e.push(value.to_hash)\n end\n json[:messageResult] = e\n end\n \n json\n end",
"def to_hash\n @hash\n end",
"def hash\r\n return to_s.hash\r\n end",
"def to_hash\n validate!\n @hash ||= json\n end",
"def to_hash\n @hash\n end",
"def to_hash\n @hash\n end",
"def hash\n return to_s.hash\n end",
"def json\n JSON.pretty_generate(hash)\n end",
"def hash\n to_s.hash\n end",
"def as_hash\n @hash\n end",
"def for_json\n to_hash\n end",
"def to_json\n return Json.dump(to_hash)\n end",
"def output_hash; end",
"def hash\n data.hash\n end",
"def sha\n result_hash['sha']\n end",
"def hash\n { hash: @hash, hashType: @hash_type }\n end",
"def hash_for_json(*)\n to_h\n end",
"def serialize\n JSON.dump(@hash)\n end",
"def to_hash() end",
"def signature\n Digest::SHA256.hexdigest(@hash.to_json)\n end",
"def to_hash\n @_hash_\n end",
"def to_result_hash\n if self.class.respond_to?(:returns) && self.class.returns.any?\n to_hash([:status] | self.class.returns)\n else\n to_hash\n end\n end",
"def to_json\n JSON.generate to_hash\n end",
"def to_json\n # convert the result to JSON\n MultiJson.dump(to_hash)\n end",
"def hash\n to_s.hash\n end",
"def hash\n to_s.hash\n end",
"def to_h\n @hash\n end",
"def to_h\n @hash\n end",
"def hash\n @hash\n end",
"def json\n @json_hash.to_json\n end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def hash\n @hash.hash\n end",
"def hash\n return unless doc_value?\n result['doc']['hash']\n end",
"def result\n ActiveSupport::JSON.encode(@buffer)\n end",
"def hash\n to_a.hash\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n return to_hash.to_json\n end",
"def to_json\n #JSON.fast_generate(to_hash)\n JSON.pretty_generate(to_hash)\n end",
"def to_json\n #JSON.fast_generate(to_hash)\n JSON.pretty_generate(to_hash)\n end",
"def to_hash\n to_a.hash\n end",
"def to_json\r\n to_hash.to_json\r\n end",
"def to_hash()\n @data\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n to_hash.to_json\n end",
"def to_json\n return self.to_hash.to_json\n end",
"def hash\n shasum.hash\n end",
"def hash\n shasum.hash\n end",
"def hash\n shasum.hash\n end",
"def to_hash\n hsh = {\n id: id,\n status: status.to_sym,\n connect: running? ? connect.to_h : nil,\n time: info.wallclock_time.to_i / 60 # only update every minute\n }\n Digest::SHA1.hexdigest(hsh.to_json)\n end",
"def to_hash\n {:hashes => @hashes}\n end",
"def stringify(result)\n JSON.parse(JSON.dump(result))\n end",
"def get_db_as_hash()\n db = get_db()\n db.results_as_hash = true \n return db\n end",
"def to_hash\n @data\n end",
"def to_hash\n @data\n end",
"def to_hash\n @data.to_hash\n end",
"def to_json()\n return @renderHash.to_json\n end",
"def to_json\n JSON.generate(to_h)\n end",
"def to_hash\n @data\n end",
"def to_jaxb_json_hash\n _h = {}\n _h['result'] = result.to_jaxb_json_hash unless result.nil?\n _h['error'] = error.to_jaxb_json_hash unless error.nil?\n _h['retorno'] = retorno.to_jaxb_json_hash unless retorno.nil?\n return _h\n end",
"def result\n Valkyrie::Persistence::Shared::JSONValueMapper.new(value).result.symbolize_keys\n end",
"def to_json\n self.to_hash.to_json\n end",
"def serialize\n self.to_hash.to_json\n end",
"def format_hash(hash)\n return hash.to_json\n end",
"def results_hash\n hash = {:updated => [],\n :merged => [],\n :removed => [],\n :unresolved => []}\n\n class << hash\n def success?; self[:unresolved].empty?; end\n end\n hash\n end",
"def hash(option_json)\n\t\tif(File.exist?(GROWTH::GROWTH_REPOSITORY))then\n\t\t\tg = Git.open(GROWTH::GROWTH_REPOSITORY)\n\t\t\treturn {status: \"ok\", hash: g.log()[-1].sha}\n\t\telse\n\t\t\treturn {status: \"error\", message: \"GRWOTH git repository '#{GROWTH::GROWTH_REPOSITORY}' not found \"}\n\t\tend\n\tend",
"def hash\n end",
"def hash\n end",
"def hash\n end",
"def hash_for_json(state = T.unsafe(nil)); end",
"def to_json(*)\n to_hash.to_json\n end",
"def to_json\n Oj.dump(to_hash)\n end",
"def hash\n @hash || calculate_hash!\n end",
"def to_hash\n return self\n end",
"def to_json(_options = nil)\n @json ||= @hash ? @hash.to_json : \"\"\n end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def serialize\n JSON.generate(to_h)\n end",
"def to_hash\n data.to_hash\n end"
] | [
"0.71402216",
"0.70310307",
"0.7001798",
"0.69816375",
"0.6981057",
"0.6981057",
"0.69720805",
"0.69235444",
"0.6844965",
"0.6837753",
"0.6802685",
"0.6796259",
"0.6784472",
"0.6756732",
"0.6756398",
"0.67051995",
"0.66957545",
"0.6682542",
"0.6680088",
"0.6658828",
"0.66224647",
"0.6621606",
"0.6613627",
"0.65995365",
"0.6593712",
"0.6593712",
"0.65875775",
"0.65875775",
"0.6583189",
"0.6568715",
"0.6558711",
"0.6558711",
"0.6558711",
"0.6558711",
"0.6558711",
"0.6558711",
"0.65493226",
"0.6544819",
"0.65346485",
"0.65182936",
"0.6503933",
"0.6503933",
"0.6501937",
"0.65018857",
"0.65018857",
"0.65008616",
"0.6498034",
"0.6494334",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6472979",
"0.6459909",
"0.6410692",
"0.6410692",
"0.6410692",
"0.64046746",
"0.63861585",
"0.63861287",
"0.6375952",
"0.63719976",
"0.63704604",
"0.6355718",
"0.6350194",
"0.6343849",
"0.6310483",
"0.63070524",
"0.630282",
"0.63027334",
"0.6298853",
"0.6296992",
"0.6292754",
"0.62916005",
"0.62898827",
"0.62898827",
"0.62898827",
"0.6287527",
"0.6286968",
"0.62333935",
"0.6227176",
"0.621334",
"0.6210747",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.6208577",
"0.62076324",
"0.62037086"
] | 0.0 | -1 |
Add attributes to the result hash in a variety of ways | def attributes(*args, &block)
if current_object.nil?
raise(ArgumentError, "You cannot use #attributes when inferred object is not present.")
end
args.each do |arg|
if arg.is_a?(Hash)
merge_result!(arg.keys.first, current_object.send(arg.values.first))
else
merge_result!(arg, current_object.send(arg))
end
end
nil
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_attributes(attr_hash)\n return unless attr_hash\n attr_hash.each_pair{ |k,v| self.add_attribute(k, v) }\n end",
"def add_attrs! attrs\n raise \"InvalidAttributesFormat\" unless attrs.is_a?(Hash)\n self.attributes.merge!attrs\n end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each do |attr, value| #from the hash get each attribute and value\n self.send(\"#{attr}=\", value) #send the studen tthe new attribute/value key pair\n end #end the each-do\n self #call self\n end",
"def hashify_attributes(attrs)\n Hash.new.tap{ |h| attrs.each{|a| h[a] = self.send(a)} }\n end",
"def add_infos(hash)\n self.custom_attributes.merge!(hash)\n end",
"def serializable_hash options=nil\n hash = super\n eav_attributes_list.each do |attribute|\n hash[attribute] = self.send(attribute)\n end\n\n hash\n end",
"def associate_attributes(attributes)\n return attributes.each_with_object({}) do |pair, hash|\n hash[pair[0]] = pair[1]\n end\n end",
"def to_hash\n fattrs.inject({}){|h,a| h.update a => send(a)}\n end",
"def attributes_hash(object); end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each {|k,v| self.send((\"#{k}=\"), v)}\n end",
"def hash_attributes(*method_names, **options)\n options = { **options, strategy: :write_value_using_hash_strategy }\n method_names.each { |name| _attributes[name] = options }\n end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each {|k,v| self.send((\"#{k}=\"), v)}\n end",
"def to_hash *args\n hsh = super(*args)\n hsh.each do |attr, val|\n hsh[attr] = val.to_hash if val.respond_to?(:to_hash)\n end\n hsh\n end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each do |k, v|\n self.send((\"#{k}=\"), v)\n end\n end",
"def with_attributes(attributes_hash)\n attributes_hash = attributes.merge(attributes_hash)\n Context.with_value(CURRENT_ATTRIBUTES_HASH, attributes_hash) { |c, h| yield h, c }\n end",
"def add_student_attributes(attributes_hash)\n # Iterate over the given hash and use meta-programming to\n # dynamically assign student attr per the key/value pairs\n \n attributes_hash.each { |key, value| self.send((\"#{key.to_s}=\"), value)}\n \n end",
"def attr_rw_hash(*attrs)\n attrs.each do |attr|\n class_eval %{\n def self.#{attr}(args = {})\n unless instance_variable_defined?(:@#{attr})\n @#{attr} = InheritableAttr.inherit_for(self, :#{attr})\n end\n (@#{attr} ||= {}).merge!(args)\n end\n def self.#{attr}!(args = {})\n @#{attr} = {}\n @#{attr}.merge!(args)\n end\n def #{attr}\n self.class.#{attr}\n end\n }\n end\n\n register_attrs(:hash, *attrs)\n end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each {|key,value| self.send((\"#{key}=\"),value)}\n end",
"def collect(*args) # :nodoc:\n args.inject({}) do |buffer, attr_name|\n value = send(attr_name)\n buffer[attr_name] = value if value\n buffer\n end\n end",
"def add_to_hash(hash)\n super\n contact.add_to_hash(hash)\n hash['user_over_13'] = @user_over_13 || !@new_user\n hash['last_logged_in'] = fmt_date_time(@data_object.user_last_logged_in)\n hash['first_logged_in'] = fmt_date_time(@data_object.user_first_logged_in)\n# aff_opts = Affiliate.options\n\n hash\n end",
"def set_attributes(args)\n attributes = Hash.new\n attributes[:totalResults] = args[:result][:jobs][:total]\n attributes[:code] = '200'\n attributes[:msg] = \"OK\"\n attributes[:page] = args[:page]\n attributes[:last] = args[:result][:jobs][:total] / args[:page_size]\n attributes[:key] = args[:keywords]\n attributes[:jobs] = parse_raw_data(args[:result])\n OpenStruct.new(attributes)\n end",
"def attributes= hsh\n conv_hsh = {}\n hsh.each do |k,v|\n k = k.to_s.gsub(/:/,'_') if k =~ /:/\n conv_hsh[k] = v\n end\n super hsh\n end",
"def hash\n model.hash + key.hash\n end",
"def attributes(hash)\n hash.keys.inject(\"\") { |attrs, key| attrs + %{#{key}=\"#{hash[key]}\" } }\n end",
"def add_student_attributes(attributes_hash)\n attributes_hash.each {|key, value| self.send((\"#{key}=\"), value)\n }\n end",
"def add_to_hash hash = { }\n hash[self.class.value_name] = code\n if respond_to?(:uuid) \n hash[self.class.value_name_uuid] = initialize_uuid!\n end\n hash\n end",
"def dynamic_attributes_hash\n @dynamic_attributes.inject({}) { |h, da| h[da.name] = da; h}\n end",
"def add_attributes(out, attrs, well_known_map)\n if attrs.include?(:name)\n wk = well_known_map[attrs[:name]]\n raise RuntimeError, \"unknown name: #{attrs[:name]}\" unless wk\n attrs = attrs.merge(wk)\n end\n attrs.each {|attr, val| out << ' %s=\"%s\"' % [attr, val] if attr.is_a?(String)}\nend",
"def add_student_attributes(attributes_hash) #instance variables assign to key,value\n attributes_hash.each do |key,value| \n if key == :twitter\n @twitter = value\n elsif\n key == :linkedin\n @linkedin = value\n elsif\n key == :github\n @github = value\n elsif\n key == :blog\n @blog = value\n elsif\n key == :profile_quote\n @profile_quote = value\n elsif\n key == :profile_url\n @profile_url = value\n elsif\n key == :bio\n @bio = value\n end\n end\n # binding.pry\n end",
"def project_attribute_hash\n to_a.inject({}) { |hash,(k,v)| hash[k] = v }\n end",
"def as_hash(add_ins = {})\n hash = {\n :id => self.id,\n :name => self.name,\n :user_id => self.user_id,\n :wrapped_user_id => self.wrapped_user_id,\n }\n hash = hash.merge(add_ins)\n # if a wrapped user, add in user related info\n hash[:user] = wrapped_user.basic_user_info_hash if self.wrapped_user_id\n hash\n end",
"def create_attrs hash\n r = hash.map { |k,v| \"#{k}=\\\"#{escape_attr v.to_s}\\\"\" }.join(' ')\n \" #{r}\" unless r.empty?\n end",
"def hash_with_meta\n to_hash.merge(leased: VLANLease.where(pool_id: id).count)\n end",
"def build_extra_attributes\n map = Hash[extra_attributes.map { |k| [k.spec_id, k] }]\n\n # Add any attributes that do not exist yet\n club.extra_attributes.each do |spec|\n if !map[spec.id]\n map[spec.id] = ExtraAttribute.new\n extra_attributes << map[spec.id]\n end\n\n # Set the relation = a relation less that needs to be queried later\n map[spec.id].spec = spec\n end\n\n # Keep them in order\n # TODO: delete attributes that do not exist in club.extra_attributes\n extra_attributes.sort_by { |s| s.spec.position }\n end",
"def to_hash\n self.class.attributes.inject({}) { |memo, name| memo[name] = send(name); memo }\n end",
"def build_from_hash(attributes)\n\n end",
"def add(hash); end",
"def add_additional_attributes\n\n\t\t#gets an array of scraped attributes from the Scraper Class method #scrape_specific_concert\n\t\tattribute_array = SfBayAreaConcertsCliApp::Scraper.scrape_specific_concert(self.url)\n\t\n\t\t#assigns the attributes to the concert instance based on the array index\n\t\tself.ticket_price = attribute_array[0]\n\t\tself.bio = attribute_array[1]\n\t\tself.artist_website = attribute_array[2]\n\t\tself.where_to_find_music = attribute_array[3]\n\t\tself.facebook = attribute_array[4]\n\t\tself.twitter = attribute_array[5]\n\t\tself.instagram = attribute_array[6]\n\t\tself.youtube = attribute_array[7]\n\t\tself.buy_tickets_link = attribute_array[8]\n\t\t\n\tend",
"def hash\n \"#{self.class.name}-#{self.id}-#{@__metadata__.cas}-#{@__attributes__.hash}\".hash\n end",
"def set_attrs(hash, clobber=true, target = nil)\n target ||= @attrs\n if clobber\n target.merge!(hash)\n hash\n else\n hash.each do |k, v|\n if v.is_a?(Hash)\n set_attrs(v, clobber, target[k])\n else\n target[k] = v\n end\n end\n end\nend",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def to_hash\n r = ATTR_NAMES.inject({}) { |m,e|\n m[e] = self.send(e)\n m\n }\n r[:product_identity_id] = product_identity_id\n r[:langcode] = lang_code_3_chars\n r[:mappings] = mappings\n r\n end",
"def copied_attributes\n\t\tattrs = {}\n\t\tattrs[:key] = self.key\n\t\tattrs[:value] = self.value\n\t\tattrs[:description] = self.description\n\t\tattrs[:reference_id] = self.id\n\t\tattrs[:rider_id] = self.rider_id\n\t\tattrs[:tag_list] = self.tag_list\n\n\t\tattrs\n\tend",
"def add_student_attributes(attributes_hash)\n attributes_hash.each do |key, value|\n self.send(\"#{key}=\", value)\n end\n self\n end",
"def attr_hash(attrs)\n h = {}\n attrs.each {|k,v| h[k] = v}\n h\n end",
"def extra_attributes_attributes=(attributes)\n map = Hash[extra_attributes.map { |k| [k.spec_id, k] }]\n method = attributes.respond_to?(:each_value) ? :each_value : :each\n attributes.send(method) do |attribute|\n if attribute['spec_id'] && map[attribute['spec_id'].to_i]\n map[attribute['spec_id'].to_i].value = attribute['value']\n end\n end\n end",
"def all_attrs\n key_attrs.merge(other_attrs)\n end",
"def merge( attributes )\n\t\tattributes.each do |attrname, value|\n\t\t\tself[ attrname ] = value\n\t\tend\n\tend",
"def calculate_hash!\n entry_hash = to_hash\n entry_hash['description']=nil\n @hash = entry_hash.hash\n end",
"def attr_hash\n hash = create_hash\n hash.delete(\"id\")\n hash.delete(\"errors\")\n return hash\n end",
"def each_hash(result) # :nodoc:\n raise NotImplementedError\n end",
"def make_hash\n variables = self.instance_variables\n attr_hash = {}\n \n variables.each do |var|\n attr_hash[\"#{var.slice(1..-1)}\"] = self.send(\"#{var.slice(1..-1)}\")\n end\n \n attr_hash\n end",
"def create_attr_hash\n data = {}\n self.instance_variables.each do |attr|\n value = self.instance_variable_get(attr)\n key = attr.to_s.sub(%r{^\\@}, '').sub(%r{\\@}, '')\n if @attr_list.include?(key)\n data[key] = value\n end\n end\n\n data\n end",
"def hash\n [attribute, statistics, other, total, missing, term_count, term_type, terms].hash\n end",
"def to_hash\n args_hash = {}\n arguments.each { |k,v| args_hash[k] = v.attributes } if arguments\n { return_type: return_type }.merge args_hash\n end",
"def to_hash\n _attributes_.inject({}) { |h, (k,v)| h[k] = eval_as_proc(v); h }\n end",
"def attributes\n ATTRIBUTES.inject({}) do |hash, attribute|\n hash[attribute] = self.send(attribute)\n hash\n end\n end",
"def attributes\n ATTRIBUTES.inject({}) do |hash, attribute|\n hash[attribute] = self.send(attribute)\n hash\n end\n end",
"def hash\n @attrs\n end",
"def attributes\n [@attribute,@value].inject(Hash.new([])) do |memo,c|\n case c \n when Sower::Relation::Statement, Sower::Relation::Attribute, Sower::Relation::Value::Base\n memo.merge!(c.attributes){|k,v,n| v | n}\n end\n memo\n end\n end",
"def hit_on_attributes attrhash, site\n return unless results.present? && site\n attrhash.each do |label, value_or_set|\n if value_or_set.is_a? Hash\n (value_or_set = value_or_set.values).map { |value|\n hit_on_attribute label, value, site\n }\n else\n hit_on_attribute label, value_or_set, site\n end\n end\n end",
"def attributes(new_attrs)\n @new_attrs = new_attrs.symbolize_keys\n attrs = original_attributes.merge(@new_attrs.merge({\n is_current_version: true,\n id: @record.id,\n version: @record.version + 1\n }))\n end",
"def with(new_attrs)\n self.class.new(to_h.merge(new_attrs))\n end",
"def add_attrs(h)\n @app.log << \"add_attrs #{h.inspect[1..-2]}\"\n @app.add_attrs(h)\nend",
"def attribute(opts)\n raise ArgumentError unless opts.is_a?(Hash)\n @attributes << Attribute.new(opts)\n end",
"def deep_hash_merge(query_hash, attribute_hash)\n query_hash.merge(attribute_hash) do |_key, oldval, newval|\n oldval = oldval.to_hash if oldval.respond_to?(:to_hash)\n newval = newval.to_hash if newval.respond_to?(:to_hash)\n oldval.class.to_s == 'Hash' && newval.class.to_s == 'Hash' ? deep_hash_merge(oldval, newval) : newval\n end\n end",
"def with_attribute(attributes)\n @attributes.merge!(attributes)\n self\n end",
"def current_attributes\n attributes.each_key.each_with_object({}) do |key, h|\n h[key] = public_send(key)\n end\n end",
"def add_student_attributes(attributes_hash)\n @twitter = attributes_hash[:twitter]\n @linkedin = attributes_hash[:linkedin]\n @github = attributes_hash[:github]\n @blog = attributes_hash[:blog]\n @profile_quote = attributes_hash[:profile_quote]\n @bio = attributes_hash[:bio]\n # @profile_url = attributes_hash[:profile_url]\n self\n end",
"def to_h\n each_with_object({}) { |attr, h| h[attr.name] = attr }\n end",
"def apply_attributes(attributes)\n attributes.each { |k, v| self[k] = v }\n return self\n end",
"def attrs=(hash)\n super(hash.is_a?(Hash) ? hash.to_json.to_s : '{}')\n end",
"def hash\n [self.class, self.val, self.attribute].hash\n end",
"def attribute_hash\n video.attribute_hash.merge({'key' => key})\n end",
"def all_attributes=(hash = {})\n hash.each { |k, v| set_attribute(k, v) }\n self\n end",
"def transform_attr(key, value); end",
"def keyword_value_hash\n self.data_attributes.inject({}) do |hsh, a| \n if a.class == ImportAttribute\n hsh.merge!(a.import_predicate => a.value)\n else # there are only two\n hsh.merge!(a.predicate.name => a.value)\n end\n end \n end",
"def add_student_attributes(student_hash)\n @twitter = student_hash[:twitter]\n @linkedin = student_hash[:linkedin]\n @github = student_hash[:github]\n @blog = student_hash[:blog]\n @profile_quote = student_hash[:profile_quote]\n @bio = student_hash[:bio]\n @profile_url = student_hash[:profile_url]\n\n end",
"def merge!(attributes)\n raise TypeError.new(\"can't convert #{attributes.class} into Hash\") unless attributes.kind_of?(Hash)\n attributes.each do |key, value|\n self[key] = value\n end\n end",
"def attributes_hash\n fail 'sub class to implement'\n end",
"def add_attributes(record, attrs)\n if attrs.is_a?(Array)\n attrs.each { |attr| self.add_attribute(record, attr) }\n elsif attrs.is_a?(Hash)\n attrs.each do |attr_name, value|\n self.add_attribute(record, attr_name, value)\n end\n else\n self.add_attribute(record, attrs)\n end\n end",
"def copied_attributes\n\t\tattrs = {}\n\t\tattrs[:year] = self.year\n\t\tattrs[:age] = self.age\n\t\tattrs[:amount] = self.amount\n\t\tattrs[:rate] = self.rate\n\n\t\tattrs\n\tend",
"def assemble_hash(data, object)\n return if data[:property].blank?\n\n @result ||= {}\n if data[:multiple]\n @result[data[:property].to_sym] ||= []\n @result[data[:property].to_sym] += [object]\n else\n @result[data[:property].to_sym] = object\n end\n end",
"def get_hash\n\t\thmodification = Hash.new\n\t\thmodification[:id] = hid\n\t\thmodification[:pred] = pred\n\t\thmodification[:obj] = obj.hid\n\t\thmodification\n\tend",
"def hash_at(i, attrs)\n attrs.inject({}) { |a, h| h[a] = value_hash[a][i]; h}\n end",
"def to_hash\n attributes.dup\n end",
"def attributes\n self.attribute_keys.inject({}) do |hash, key|\n hash[key] = self.__send__(key) if self.__send__(key)\n hash\n end\n end",
"def build_hash_for_savon_call(attributes = {}, options = {})\n user_info = {user_info: {username: config.username, password: config.password}}\n message = user_info.merge attributes\n\n if default_keys = options[:include_defaults]\n message = DEFAULTS.slice(*Array.wrap(default_keys)).deep_merge message\n end\n\n if order = ORDER[options[:operation_name]]\n unkown_keys = attributes.keys - order\n\n if unkown_keys.any?\n fail ArgumentError, \"Unkown attribute(s) given to #{options[:operation_name]}: #{unkown_keys.join(', ')}. Attributes' order is defined in #{self.class.name}::ORDER, but you sent in something we do not have.\"\n end\n\n message[:order!] = order & message.keys\n end\n\n {\n message: transform_hash_for_quest_back(message)\n }\n end",
"def apply\n scalar_attrs.each { |m| applicator(m) { |r| send(m, r) } }\n list_attrs.each { |m| applicator(m) { |r| send(m, *r) } }\n hash_attrs.each { |m| applicator(m) { |r| send(m).merge!(r) } }\n path_attrs.each { |m| applicator(m) { |r| send(\"#{m}=\", r) } }\n end",
"def rebuild_with(attributes)\n self.class.new(to_h.deep_merge(attributes))\n end",
"def attr_hash\n Digest::MD5.hexdigest(\"#{@name}:#{@ruby_type}\")\n end",
"def assign_attributes(hash)\n hash.each { |k, v| send(\"#{k}=\", v) }\n end",
"def field_hash\n\n self.yattributes || fields.inject({}) { |r, f| r[f.fkey] = f.value; r }\n end",
"def attributes_hash\n self.info.to_hash.symbolize_keys\n end",
"def attributes\n self._attributes.inject({}) do |hash, attr|\n hash[attr.to_s] = send(attr)\n hash\n end\n end",
"def attributes= new_attributes\n ingest_attributes(new_attributes)\n end",
"def attributes\n _fast_attributes\n\n rescue NameError\n\n method = \"def _fast_attributes\\n\"\n method << \" @_attributes ||=\\n\"\n method << \" begin\\n\"\n method << \" h = {}\\n\"\n\n self.class.attributes.each do |name|\n method << \" h[:\\\"#{name}\\\"] = send(:\\\"#{name}\\\") if include_#{name}?\\n\"\n end\n\n method << \" h\\n\"\n method << \" end\\n\"\n method << \"end\"\n\n self.class.class_eval method\n\n _fast_attributes\n end",
"def to_h\n self.class.list_of_attributes.each_with_object({}) do |key, hash|\n val = instance_variable_get :\"@#{key}\"\n hash[key] = Utils.hashify(val) unless val == Dry::Initializer::UNDEFINED\n end\n end",
"def export_attributes(hash = nil, options = {})\n attribute_map.assign_context = self\n\n hash ||= attributes\n attribute_map.map_attributes(hash, options)\n end"
] | [
"0.6698538",
"0.6583141",
"0.646759",
"0.6326051",
"0.63176715",
"0.62962383",
"0.6254876",
"0.6244898",
"0.62373084",
"0.6173945",
"0.6171681",
"0.6171439",
"0.61409885",
"0.61389065",
"0.61293733",
"0.6116245",
"0.6096952",
"0.6071564",
"0.6053079",
"0.6048596",
"0.60350424",
"0.60125613",
"0.6011605",
"0.6002386",
"0.600223",
"0.5988781",
"0.5987772",
"0.5977075",
"0.5967211",
"0.5964482",
"0.5959141",
"0.5935546",
"0.5918674",
"0.588216",
"0.5879385",
"0.5871177",
"0.58702385",
"0.58160317",
"0.5815632",
"0.58129656",
"0.58073413",
"0.58073413",
"0.58073413",
"0.5802284",
"0.57890105",
"0.578672",
"0.5785858",
"0.5785142",
"0.57753",
"0.5767865",
"0.57592386",
"0.5758078",
"0.57505727",
"0.5750335",
"0.57435066",
"0.5739686",
"0.5730404",
"0.572694",
"0.5706793",
"0.5706793",
"0.5704744",
"0.57021403",
"0.5684227",
"0.56780034",
"0.5676319",
"0.5672441",
"0.5667853",
"0.5667385",
"0.56581336",
"0.5653431",
"0.564787",
"0.5643343",
"0.563545",
"0.561703",
"0.5614226",
"0.5610426",
"0.56102514",
"0.5604681",
"0.5603835",
"0.56002307",
"0.5596951",
"0.55909455",
"0.55907613",
"0.55883753",
"0.5587684",
"0.5584442",
"0.55791634",
"0.5576627",
"0.5570843",
"0.5558278",
"0.5550938",
"0.55492634",
"0.5545154",
"0.5536179",
"0.55359393",
"0.55351734",
"0.5530557",
"0.5528831",
"0.552204",
"0.55217165",
"0.55184853"
] | 0.0 | -1 |
Merges values into the "local" result hash. | def merge_result!(key, val)
if key
result[key] = massage_value(val)
else
result.merge!(massage_value(val))
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(hash); end",
"def merge(hash); end",
"def merge(hash); end",
"def merge(other_hash); end",
"def merge!(*other_hashes, &blk); end",
"def merged_result; end",
"def hash_merger(query_vals)#another hash that is nested)\n merged_hash = Hash.new\n # for each key_val_set\n # check if key exists in merged_hash\n # if not - add in the value\n # if yes - key into merged_hash with key, and check next key\n\n query_vals.each do |keys, val|\n current = merged_hash\n keys.each_with_index do |key,i|\n if i == keys.length - 1\n current[key] = val\n else\n current[key] ||= {}\n current = current[key]\n end\n end\n end\n merged_hash\n end",
"def merge(*other_hashes, &blk); end",
"def merge_values!(values)\n # STUB: should make recorsive calls if need\n global_config[target] ||= {}\n global_config[target].merge!(values)\n end",
"def merge!(other_hash); end",
"def custom_merge(hash1, hash2)\n fin=hash1.dup\n hash2.each do |ky,val|\n fin[ky]=val\n end\n fin\nend",
"def merge!(hash); end",
"def merge(hash_1, hash_2)\n\nend",
"def merge(hash_1, hash_2)\n new_hash = Hash.new()\n\n hash_1.each {|key, value| new_hash[key] = value}\n\n hash_2.each {|key, value| new_hash[key] = value}\n new_hash\nend",
"def merge(base_hash, derived_hash); end",
"def concat_merge original\n {}.tap do |result|\n original.each do |element|\n element.each_pair do |key, value|\n if value.is_a?(Array)\n result[key] ||= []\n result[key].concat value\n merge_if_equals(result[key])\n else\n result[key] = value\n end\n end\n end\n end\n end",
"def merge_results_from_worker(results)\n @mutex.synchronize do\n results.each do |r|\n new_props = @job_inst.collector_combine_block(r, @n, @val)\n @n = new_props[:n]\n @val = new_props[:val]\n end\n end\n end",
"def combined_hash\n y = if @process_global\n normalize(global_yaml).rmerge(normalize(yaml))\n else\n normalize(yaml)\n end\n @process_local ? y.rmerge(normalize(local_yaml)) : y\n end",
"def custom_merge(hash1, hash2)\n output = hash1.dup\n hash2.each { |key, value| output[key] = value }\n output\nend",
"def merge(base_hash, derived_hash, **opts); end",
"def deep_merge_hashes(master_hash, other_hash); end",
"def merge hash = {}\n original.merge(hash)\n end",
"def merge\n a_hash = without_empty_values @a.to_h\n b_hash = without_empty_values @b.to_h\n\n @a.class.new a_hash.merge b_hash\n end",
"def custom_merge(hash1, hash2)\n new_hash = hash1.dup\n hash2.each { |key, value| new_hash[key] = value }\n new_hash\nend",
"def calculate_values_hashes\n @values_hashes || recalculate_values_hashes\n end",
"def deep_merge!(*other_hashes, &blk); end",
"def deep_merge(*other_hashes, &blk); end",
"def merge_results(*results); end",
"def merge_results(*results); end",
"def merge_results(*results); end",
"def custom_merge(hash1, hash2)\n new_hash = hash1.dup\n hash2.each do |key, value|\n new_hash[key] = value\n end\nend",
"def deep_merge(source, hash); end",
"def deep_merge(source, hash); end",
"def _rh_merge(result, data)\n return _rh_merge_choose_data(result, data) unless data.is_a?(Hash)\n\n data.each do |key, _value|\n next if [:__struct_changing, :__protected].include?(key)\n\n _do_rh_merge(result, key, data)\n end\n [:__struct_changing, :__protected].each do |key|\n # Refuse merge by default if key data type are different.\n # This assume that the first layer merge has set\n # :__unset as a Hash, and :__protected as an Array.\n\n _do_rh_merge(result, key, data, true) if data.key?(key)\n\n # Remove all control element in arrays\n _rh_remove_control(result[key]) if result.key?(key)\n end\n\n result\n end",
"def merge(hash)\n hash.each_value { |v| self << v }\n end",
"def custom_merge(hash1, hash2)\n new_hash = hash1.dup\n hash2.each do |k, v|\n new_hash[k] = v\n end\n new_hash\nend",
"def merge_values(h1, h2)\n out = {}\n (h1.keys + h2.keys).uniq.each do |key|\n # If the key is present in both hashes\n if h1.key?(key) && h2.key?(key)\n out[key] = merge_values(h1[key], h2[key])\n elsif h1.key?(key)\n out[key] = h1[key]\n else\n out[key] = h2[key]\n end\n end\n out\nend",
"def merge(hash_1, hash_2)\n merged = {}\n hash_1.each { |key, val| merged[key] = val }\n hash_2.each { |key, val| merged[key] = val }\n merged \nend",
"def deep_merge_hashes!(target, overwrite); end",
"def merge_resultsets(result1, result2); end",
"def merge_resultsets(result1, result2); end",
"def merge!(other)\n\t\tALL.each do |key|\n\t\t\tincrement(key, other.get(key))\n\t\tend\n\t\tself\n\tend",
"def merge_two_hashes(h1, h2)\n\t\th1.merge(h2) do |key, v1, v2|\n\t\t v1 + v2\n\t\tend\n\tend",
"def shallow_merge(other_hash); end",
"def _deep_merge(hash, other_hash); end",
"def reverse_merge(other_hash); end",
"def reverse_merge(other_hash); end",
"def merge(base_hash, derived_hash)\n resolver.merge(base_hash, derived_hash)\n end",
"def combine(hash1, hash2)\n hash2.each do |k, v|\n if hash1.key?(k)\n hash1[k] = Array(hash1[k])\n hash1[k] = hash1[k] + v\n else\n hash1[k] = v\n end\n end\n hash1\n end",
"def merge( oid, values )\n\t\toid = normalize_oid( oid )\n\t\tvalues = normalize_keys( values )\n\t\t@storage[ oid ].merge!( values )\n\tend",
"def deep_merge!(other_hash, &block); end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def merge(hash)\n to_hash.merge(hash)\n end",
"def result_with_hash(hash)\n b = new_toplevel(hash.keys)\n hash.each_pair do |key, value|\n b.local_variable_set(key, value)\n end\n result(b)\n end",
"def combine_results(*hashes)\n final_hash = {\n 'http_code_distribution' => {},\n 'latency_distribution' => {}\n }\n to_add = ['errors', 'latency_sum', 'requests']\n to_combine = ['latency_distribution', 'http_code_distribution']\n\n to_add.each do |item|\n final_hash[item] = 0\n end\n\n hashes.each do |this_hash|\n next if this_hash == nil\n to_add.each do |key|\n final_hash[key] += this_hash[key] if this_hash.has_key?(key)\n end\n to_combine.each do |key|\n final_hash[key] = combine_hashes(final_hash[key], this_hash[key])\n end\n end\n return final_hash\nend",
"def merge!(hash)\n hash.each do |k,v|\n @new_info[lookup_key(k)] = v\n end\n self\n end",
"def addhashes(h1, h2)\n if h1.respond_to?(:merge) && h2.respond_to?(:merge)\n return h1.merge(h2) { |_key, old, new| addhashes(old, new) }\n else\n return h1 + h2\n end\n end",
"def merge!(other_hash)\n @lock.synchronize do\n other_hash.each { |key, value| self[key] = value }\n end\n end",
"def merge!(other_hash)\n @lock.synchronize do\n other_hash.each { |key, value| self[key] = value }\n end\n end",
"def values\n (@hash.values + @converted.values)\n end",
"def merge_map(prime, other)\n prime.merge(other) { |key,prime_value,other_value|\n case prime_value\n when Hash\n merge_map(prime_value, other_value)\n when Array\n prime_value + other_value\n else\n other_value\n end\n }\n end",
"def recalculate_values_hashes\n vh = {}\n @values.each do |k,v|\n vh[k] = v.hash\n end\n @values_hashes = vh.freeze\n end",
"def merge; end",
"def merge!(other)\n @hash.merge!(other.hash)\n end",
"def merge!(other)\n update!(other.value)\n end",
"def combine_hashes(*hashes)\n final_hash = {}\n hashes.each do |this_hash|\n # where matching, add the values.\n final_hash = final_hash.merge(this_hash) {\n |_key, oldval, newval| newval + oldval \n }\n end\n return final_hash\nend",
"def merge_players_info(keys,values_hash)\n\nplayers_hash = {}\nvalues_hash.each do |players, info|\n players_hash[players]= merge_player_info(keys,info)\nend\nplayers_hash\nend",
"def merge(*hashes, &block)\n dup.update(*hashes, &block)\n end",
"def merge(other_hash, &block)\n to_h.merge(other_hash, &block).reduce(self.class.new) do |map, pair|\n map[pair.first] = pair.last\n map\n end\n end",
"def merge(other_hash, &block)\n to_h.merge(other_hash, &block).reduce(self.class.new) do |map, pair|\n map[pair.first] = pair.last\n map\n end\n end",
"def merge(other)\n other.inject(self) { |result, entry| result << entry }\n end",
"def merged_result\n # conceptually this is just doing `merge_results(resultset_path)`\n # it's more involved to make syre `synchronize_resultset` is only used around reading\n resultset_hash = read_resultset\n command_names, coverage = merge_valid_results(resultset_hash)\n\n create_result(command_names, coverage)\n end",
"def merge_comps( original, override )\n override.each do |k,v|\n if original.has_key? k\n original[k] = v\n else\n original << [k,v]\n end\n end\n end",
"def merge(ar_1, ar_2)\n result = {}\n ar_1.each_with_object(result) { |el, result| result[el] = el}\n ar_2.each_with_object(result) { |el, result| result[el] = el}\n result.values\nend",
"def merge!(rel)\n return self if rel.nil?\n\n MULTI_VALUE_METHODS.each do |method|\n (@values[method] ||= []).concat(rel.values[method]).uniq! unless rel.values[method].nil?\n end\n\n MULTI_KEY_METHODS.each do |method|\n (@values[method] ||= {}).merge!(rel.values[method]) unless rel.values[method].nil?\n end\n\n SINGLE_VALUE_METHODS.each do |method|\n @values[method] = rel.values[method] unless rel.values[method].nil?\n end\n\n self\n end",
"def deep_merge(other_hash, &blk)\n dup.deep_update(other_hash, &blk)\n end",
"def results_hash\n hash = {:updated => [],\n :merged => [],\n :removed => [],\n :unresolved => []}\n\n class << hash\n def success?; self[:unresolved].empty?; end\n end\n hash\n end",
"def merge!(hash)\n hash.each { |k, v| self[k]= v }\n end",
"def values\n synchronize do\n @values.each_with_object({}) do |(labels, value), memo|\n memo[labels] = value\n end\n end\n end",
"def merge!(other)\n o = dup\n other.each do |k,v|\n o.store!(k,v)\n end\n o\n end",
"def _do_rh_merge(result, key, data, refuse_discordance = false)\n value = data[key]\n\n return if _rh_merge_do_add_key(result, key, value)\n\n return if _rh_merge_recursive(result, key, data)\n\n return if refuse_discordance\n\n return unless _rh_struct_changing_ok?(result, key, data)\n\n return unless _rh_merge_ok?(result, key)\n\n _rh_merge_do_upd_key(result, key, value)\n end",
"def combine(other)\n other.each { |key, value| setting(key).combine!(value) } if other.is_a?(Hash)\n end",
"def reverse_merge!(other_hash); end",
"def merge_data(keys,values)\n keys.each do |name_hash|\n values.each do |hash|\n name_hash.merge!(hash[name_hash[:first_name]])\n end\n end\n end",
"def merge!; end",
"def merge(hash)\n self.dup.update(hash)\n end",
"def merge!(data)\n data.each do |k,v|\n self[k] = v\n end\n end",
"def merge(with); end",
"def deep_merge!(target, hash); end",
"def deep_merge!(target, hash); end",
"def merge!(other)\n other.each_pair do |key, value|\n value = yield(convert_key(key), self[key], convert_value(value)) if block_given? && self[key]\n self[key] = value\n end\n self\n end",
"def merge_player_info(keys,values)\n counter = 0\n players_hash = {}\n keys.each do |key|\n players_hash[key] = values[counter]\n counter += 1\n end\n players_hash\nend",
"def rh_merge(data)\n _rh_merge(clone, data)\n end",
"def merge_hash!(hash)\n merge!(self.class.from_hash(hash))\n end",
"def merge(other)\n self.class[Utils.merge(to_h, other)]\n end",
"def internal_deep_merge!(source_hash, specialized_hash)\n\t\t\tspecialized_hash.each_pair do |rkey, rval|\n\t\t\t\tif source_hash.has_key?(rkey) then\n\t\t\t\t\tif rval.is_a?(Hash) and source_hash[rkey].is_a?(Hash) then\n\t\t\t\t\t\tinternal_deep_merge!(source_hash[rkey], rval)\n\t\t\t\t\telsif rval == source_hash[rkey] then\n\t\t\t\t\telse\n\t\t\t\t\t\tsource_hash[rkey] = rval\n\t\t\t\t\tend\n\t\t\t\telse\n\t\t\t\t\tsource_hash[rkey] = rval\n\t\t\t\tend\n\t\t\tend\n\t\t\tsource_hash\n\t\tend"
] | [
"0.6855965",
"0.6855965",
"0.6855965",
"0.6712077",
"0.65920377",
"0.6506063",
"0.64907116",
"0.6488673",
"0.6447995",
"0.6431979",
"0.637143",
"0.6289147",
"0.62711084",
"0.6247436",
"0.6230498",
"0.6217351",
"0.62100965",
"0.6153013",
"0.61451745",
"0.6130036",
"0.6099848",
"0.60937905",
"0.60632575",
"0.6034796",
"0.6010336",
"0.60082585",
"0.599785",
"0.59944004",
"0.5994393",
"0.5994393",
"0.5979023",
"0.5967359",
"0.5967359",
"0.5966523",
"0.5934699",
"0.59342784",
"0.59275323",
"0.5923549",
"0.58625364",
"0.58516866",
"0.5851454",
"0.58397037",
"0.58395845",
"0.582134",
"0.5797836",
"0.57919896",
"0.57919896",
"0.57912296",
"0.5786483",
"0.5752575",
"0.5725178",
"0.57106566",
"0.57106566",
"0.57106566",
"0.57106566",
"0.57106566",
"0.57106566",
"0.5704397",
"0.5698266",
"0.5693243",
"0.5679434",
"0.5675864",
"0.5675864",
"0.5673517",
"0.5646985",
"0.5643422",
"0.5636505",
"0.56256735",
"0.56206256",
"0.5618263",
"0.56145144",
"0.5609115",
"0.5607505",
"0.5607505",
"0.55662966",
"0.5560296",
"0.5557983",
"0.55544275",
"0.55519044",
"0.5550226",
"0.5548781",
"0.5546323",
"0.554604",
"0.5544841",
"0.55408716",
"0.5531973",
"0.55273485",
"0.5515154",
"0.55122423",
"0.55099124",
"0.54752475",
"0.5465557",
"0.5454253",
"0.5454253",
"0.544017",
"0.54400146",
"0.5433586",
"0.54301506",
"0.54250693",
"0.5425004"
] | 0.6741713 | 3 |
put any specializations in here | def massage_value(val)
if block = Bldr.handlers[val.class]
return block.call(val)
else
val
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def specializations\n @specializations ||= Specialization.from_models(self, @models)\n end",
"def spec_type(desc, *additional); end",
"def register_spec_type(*args, &block); end",
"def extensions_for(template_class); end",
"def extensions_for(template_class); end",
"def types(types); end",
"def standard_specs; end",
"def find_templates(name, prefix, partial, details)\n # checks if the format has a fallback chain\n if @fallback_formats.has_key?(details[:formats].first)\n details = details.dup\n details[:formats] = Array.wrap(@fallback_formats[details[:formats].first]) \n end\n super(name, prefix, partial, details)\n end",
"def register!\n self.rdf_content_types = []\n RDF::Format.each do |format|\n register_renderer(format.file_extension, format.content_type, format.symbols.first)\n end\n\n register_renderer(%i[hndjson], ['application/hex+x-ndjson'], :hndjson)\n register_renderer(%i[empjson], ['application/empathy+json'], :empjson)\n rdf_content_types.freeze\n end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def most_specific_type(from_magic_type, fallback_type); end",
"def most_specific_type(from_magic_type, fallback_type); end",
"def boot_types\n @types = {}\n type_names.each do |name , ivars |\n @types[name] = type_for( name , ivars)\n end\n type_type = @types[:Type]\n @types.each do |name , type |\n type.set_type(type_type)\n end\n end",
"def generic?; true; end",
"def registered_types\n end",
"def default_filters!\n before do\n request.path_info =~ /\\.([^\\.\\/]+)$/\n @_content_type = ($1 || :html).to_sym\n content_type(@_content_type, :charset => 'utf-8') rescue content_type('application/octet-stream')\n end\n end",
"def variants; end",
"def prefer(template_class, *extensions); end",
"def test_registration\n DocTemplate.register_format Object, 'ext1', 'ext2'\n assert_equal Object, DocTemplate::FORMATS['ext1']\n assert_equal Object, DocTemplate::FORMATS['ext2']\n end",
"def types; end",
"def types; end",
"def types; end",
"def types; end",
"def types; end",
"def traits; end",
"def route_type_listing(route)\n yield :file, route.file_path if @file_extensions.include? route.extension\n return unless handle_type? route.extension\n @extensions[route.extension].each do |value|\n yield value[:instruction], \"#{route.file_path}#{value[:extra_extension]}\"\n end\n end",
"def included(base)\n base.register self, TYPES\n end",
"def compile_all\n compile\n\n vtypes = {}\n\n @verbs.values.each do |vs|\n vs.each do |v|\n v.verbs.each do |vv|\n if vtypes[vv].nil?\n vtypes[vv] = v.type\n else\n if vtypes[vv] != v.type\n puts \"*** Verb #{vv} has multiple types (#{vtypes[vv]} and #{v.type})\"\n end\n end\n end\n end\n end\n vtypes.each do |pair|\n @parser.add_verb(pair.last, pair.first)\n end\n\n @adverbs.keys.each do |a|\n @parser.add_adverb(a)\n end\n\n if !@pending_qualities.empty?\n # now we need a dependency graph so we can order traits properly\n @pending_qualities.sorted_keys.each do |name|\n info = @pending_qualities[name]\n info[:name] = name\n regularize_traits info\n\n item = Quality.new(info)\n\n if !reported_errors? item\n @mixins[name] = item\n end\n\n @pending_qualities.delete name\n end\n end\n\n if !@pending_archetypes.empty?\n # now we need a dependency graph so we can order archetypes properly\n @pending_archetypes.sorted_keys.each do |name|\n info = @pending_archetypes[name]\n if !info.nil?\n if info[:archetype]\n archetype_name = find_archetype_name name, info[:archetype]\n if !@archetypes[archetype_name]\n puts \"Archetype #{info[:archetype]} not defined, but required by #{name}\"\n info[:archetype] = nil\n else\n info[:archetype] = @archetypes[archetype_name]\n end\n end\n\n info[:name] = name\n regularize_traits info\n\n item = Archetype.new(info)\n if !reported_errors? item\n @archetypes[name] = item\n end\n @pending_archetypes.delete name\n end\n end\n if !@pending_archetypes.empty?\n puts \"Some archetypes were not defined: #{@pending_archetypes.keys.sort.join(\", \")}\"\n end\n @pending_archetypes = nil\n end\n\n @pending.each do |p|\n self.send(p.first, *p.last)\n end\n\n self\n end",
"def supplemental_specs()\n supp_specs = []\n supp_specs << { :category => :remote, :content=> \"Reboot / KVM over IP\" }\n supp_specs << { :category => :primary_ip, :content=> \"1 IP Address\" }\n supp_specs << { :category => :host_ping, :content=> \"Host Ping\" }\n supp_specs << { :category => :response, :content=> \"Automated Notification\" }\n supp_specs << { :category => :notification, :content=> \"Email and Ticket\" }\n supp_specs << { :category => :vpn, :content=> \"Unlimited SSL VPN Users & 1 PPTP VPN User per account\" }\n supp_specs << { :category => :vulnerability, :content=> \"Nessus Vulnerability Assessment & Reporting\" }\n supp_specs\n end",
"def initialize(specifications = T.unsafe(nil)); end",
"def register(template_class, *extensions); end",
"def set_generic_traps\n super\n end",
"def add(*types)\n types.each do |mime_type|\n if mime_type.kind_of? MIME::Types\n add(*mime_type.defined_types)\n else\n if @type_variants.include?(mime_type.simplified)\n if @type_variants[mime_type.simplified].include?(mime_type)\n warn \"Type #{mime_type} already registered as a variant of #{mime_type.simplified}.\" unless defined? MIME::Types::STARTUP\n end\n end\n add_type_variant(mime_type)\n index_extensions(mime_type)\n end\n end\n end",
"def add_mime_types\n puts \"Updating Mime Types\"\n insert_into_file \"config/initializers/mime_types.rb\", :after => \"# Be sure to restart your server when you modify this file.\" do <<EOF\nMime::Type.register_alias \"text/plain\", :refworks_marc_txt\nMime::Type.register_alias \"text/plain\", :openurl_kev\nMime::Type.register \"application/x-endnote-refer\", :endnote\nMime::Type.register \"application/marc\", :marc\nMime::Type.register \"application/marcxml+xml\", :marcxml, \n [\"application/x-marc+xml\", \"application/x-marcxml+xml\", \n \"application/marc+xml\"]\nEOF\n end \n end",
"def initialize\n super\n self.specimen_class ||= infer_specimen_class(self.class)\n end",
"def all(*types); end",
"def cast_types; end",
"def setup_trait(options);end",
"def nonregular_type; end",
"def handle(*types); end",
"def register_spec_type *args, &block\n if block then\n matcher, klass = block, args.first\n else\n matcher, klass = *args\n end\n TYPES.unshift [matcher, klass]\n end",
"def prelude_type(t)\n case t\n when :render\n RenderType.new\n when :sequence\n SequenceType.new\n else\n CustomType.new(t)\n end\nend",
"def types=(_arg0); end",
"def prepare_types(elements)\n return if not elements\n elements.elements.each(\"typedef\") do\n |typedef|\n @types[typedef.attributes[\"name\"]]=typedef.attributes[\"basetype\"]\n format=typedef.elements[\"format\"].text\n if format =~ /^d-[0-9]+$/\n @decimals[typedef.attributes[\"name\"]]=format.sub(/^d-/,\"\").to_i\n end\n end\n end",
"def register_processor(pattern, klass, replace_all: T.unsafe(nil)); end",
"def generic_traps\n super\n end",
"def extends!(spec)\r\n @extended_spec.clear.push(spec)\r\n end",
"def derive_default_helpers(options)\n []\n end",
"def type_params; end",
"def type_params; end",
"def type_params; end",
"def type_params; end",
"def type_params; end",
"def content_types(*content_types)\n Sinatra::RPC::Serializer.register self, content_types\n @response_content_type = content_types.compact.first\n end",
"def add_mime_type(key, transform_method, values, new_response_headers = {}) \n enforce!(key => Symbol, values => Array)\n ResponderMixin::TYPES.update(key => \n {:request_headers => values, \n :transform_method => transform_method,\n :response_headers => new_response_headers })\n\n Merb::RenderMixin.class_eval <<-EOS\n def render_#{key}(thing = nil, opts = {})\n content_type = :#{key}\n render thing, opts\n end\n EOS\n end",
"def initialize_type_map(m = type_map)\n super\n m.register_type 'box', OID::Box.new\n m.register_type 'circle', OID::Circle.new\n m.register_type 'interval', OID::Interval.new\n m.register_type 'line', OID::Line.new\n m.register_type 'segment', OID::Segment.new\n end",
"def formats=(extensions); end",
"def extensions; end",
"def extensions; end",
"def extensions; end",
"def known\n {\n 'Occi::Core::Category' => Occi::Core::Renderers::Text::Category,\n 'Occi::Core::ActionInstance' => Occi::Core::Renderers::Text::ActionInstance,\n 'Occi::Core::Collection' => Occi::Core::Renderers::Text::Collection,\n 'Occi::Core::Model' => Occi::Core::Renderers::Text::Model,\n 'Occi::Core::Resource' => Occi::Core::Renderers::Text::Resource,\n 'Occi::Core::Link' => Occi::Core::Renderers::Text::Link,\n 'Occi::Core::Locations' => Occi::Core::Renderers::Text::Locations\n }\n end",
"def initialize(exts = {})\n super({\n no_images: true, no_styles: true, hard_wrap: true\n }.merge(exts))\n end",
"def initialize\n TYPES.each do |type|\n transform_files!(Files.type_files(type), type)\n end\n end",
"def media_type_representations\n custom_representations + Restfulie::MediaType.default_representations.dup\n end",
"def _wrapper_formats; end",
"def custom_type_one\n one_helper + shared\n end",
"def use_types_from(typekit)\n if typekit.respond_to?(:to_str)\n loader.typekit_model_from_name(typekit)\n else loader.register_typekit_model(typekit)\n end\n end",
"def get_all_typographies\n @typographies.values.compact.insert(0, @typography)\n end",
"def typify(api_map); end",
"def define_helpers; end",
"def polymorphic_mappings; end",
"def set_extra_stuff\n @templates = Template.all\n @tags = tags_for('Common')\n end",
"def method_missing(m, *args)\n if m.to_s[/count_(.+)_raters/]\n raters_by_type_count($1.singularize.classify)\n elsif m.to_s[/(.+)_raters/]\n raters_by_type($1.singularize.classify)\n else\n super\n end\n end",
"def add_to_mixable_app_types #:nodoc:\n paths = load_paths.collect {|path| File.expand_path(path)}\n paths.each do |path|\n if path =~ /app\\/([^\\/]+)(\\/.*)?$/\n type = $1.to_sym\n Dependencies.mixable_app_types[type] ||= /.+/\n end\n end\n end",
"def all(path, type); end",
"def record_class_definitions\n extant, novel = [], []\n ObjectSpace.each_object(Class) { |k| extant << k }\n yield\n ObjectSpace.each_object(Class) { |k| novel << k if !extant.include?(k) }\n novel\n end",
"def templates; end",
"def type() end",
"def included(klass); end",
"def included(klass); end",
"def render_get_all\n respond_to do |wants| \n wants.html {render :to_xml => 'GETALL.xml.builder', :layout => false}\n wants.json {render :to_json => 'GETALL.xml.builder'}\n wants.xml {render :to_xml => 'GETALL.xml.builder', :layout => false}\n wants.yaml {render :to_yaml => 'GETALL.xml.builder'}\n end \n end",
"def explain_types; end",
"def as_json(_options = {})\n super include: %i[sample_type object_type]\n end",
"def to_s\n <%= add_to_s %>\n end\n\n # @!group Constants\n<%= add_consts %>\n # @!endgroup\n\n # methods\n<%= add_methods %>\n\n # @!group Specializing\n<%= add_specializing %>\n # @!endgroup\n\n # types\n<%= add_types %>\n\nend",
"def determine_template(options); end",
"def templates=(_arg0); end",
"def template_types_for_view\n\t\ttt = {}\n\t\tif File.exists?(theme_template_path + '/skin.liquid')\n\t\t\ttt[:rooms] = 'Rooms-Templates'\n\t\tend\n\t\tif File.exists?(theme_template_path + '/tickets')\n\t\t\ttt[:events] = 'Events-Templates'\n\t\tend\n\t\tif File.exists?(theme_template_path + '/vouchers')\n tt[:vouchers] = 'Voucher-Templates'\n end\n\t\treturn tt\n\tend",
"def fallbacks; end",
"def fallbacks; end",
"def format_specific_setup\n format = document_partial_name(@document)\n if self.respond_to?(\"#{format}_setup\".to_sym)\n send(\"#{format}_setup\".to_sym)\n else\n logger.debug \"Didn't set up any format-specific info for #{format}. To enable custom before_render callbacks for this format, define a filter method called #{format}_setup\"\n end\n # case format\n # when \"auction\"\n # setup_auction_info\n # else\n # logger.debug \"Didn't set up any format-specific info for #{format}\"\n # end\n end",
"def formatters; end",
"def test_set_method_types\n end",
"def snat_type\n super\n end",
"def set_traits(*args)\n @traits = Traits.all.map {|key,value| [key, value.select {|k,v| \n args.include? k}]}.to_h \n self.traits.each_pair do |key, value| \n instance_variable_set(\"@#{key}\", value)\n self.class.instance_eval { attr_accessor key.to_sym, :name, :traits }\n end \n end",
"def get_available_template_types\n\t\tskin = @params['from']\n\t\tskin_dir = File.join(THEMES, skin)\n\t\toptions = []\n\t\tif File.exists? File.join(skin_dir, \"templates\", \"skin.liquid\")\n\t\t\toptions << create_checkbox(\"functions\", \"rooms\", \"Rooms\", \"validate-one-required\")\n\t\tend\n\t\tif File.exists? File.join(skin_dir, \"templates\", \"tickets\")\n\t\t\toptions << create_checkbox(\"functions\", \"events\", \"Events\", \"validate-one-required\")\n\t\tend\n\t\tif File.exists? File.join(skin_dir, \"templates\", \"vouchers\")\n\t\t options << create_checkbox(\"functions\", \"vouchers\", \"Vouchers\", \"validate-one-required\")\n\t\tend\n\t\toptions = options.join(\"<br />\")\n\t\trender :text => options\n\tend",
"def match(klass); end",
"def view_types(for_select = true) # get the defined view type partials. e.g. views/views/list.html.erb\n fetch_array_for get_view_types, for_select\n end",
"def needed_types\n self.scan unless @needed_types\n @needed_types\n end"
] | [
"0.61253786",
"0.60208654",
"0.5963748",
"0.59382904",
"0.59382904",
"0.59060836",
"0.57499653",
"0.55216056",
"0.550007",
"0.54944545",
"0.54944545",
"0.54944545",
"0.54944545",
"0.5388674",
"0.5388674",
"0.537798",
"0.5338946",
"0.53368664",
"0.5322478",
"0.5298045",
"0.5293659",
"0.5274396",
"0.52500105",
"0.52500105",
"0.52500105",
"0.52500105",
"0.52500105",
"0.5228738",
"0.5192343",
"0.5190116",
"0.5185226",
"0.51833016",
"0.5178465",
"0.51502395",
"0.51456124",
"0.512935",
"0.51064944",
"0.5097109",
"0.50923735",
"0.5089712",
"0.5088353",
"0.50739115",
"0.50691843",
"0.5061922",
"0.50572336",
"0.50562555",
"0.5041677",
"0.50415486",
"0.5039403",
"0.50380963",
"0.50343615",
"0.5033797",
"0.5033797",
"0.5033797",
"0.5033797",
"0.5033797",
"0.5032034",
"0.5013201",
"0.49906743",
"0.49861652",
"0.49715683",
"0.49715683",
"0.49715683",
"0.49656546",
"0.49650806",
"0.49534854",
"0.49483508",
"0.49442008",
"0.49441618",
"0.49436155",
"0.49342638",
"0.49173722",
"0.49083072",
"0.49071336",
"0.49026224",
"0.4881748",
"0.486277",
"0.48565915",
"0.48549244",
"0.48494604",
"0.4846521",
"0.48437133",
"0.48437133",
"0.4842053",
"0.48402134",
"0.48400277",
"0.48348483",
"0.4831073",
"0.48262602",
"0.4822339",
"0.48213932",
"0.48213932",
"0.48184097",
"0.48158064",
"0.48145768",
"0.4812947",
"0.48106477",
"0.48098034",
"0.48082736",
"0.48039237",
"0.479699"
] | 0.0 | -1 |
String representation of the grammatical category. | def to_s
"Grammatical category: #{self.tag} - '#{self.name}'"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def category_string\n categories.pluck(:name).flatten.compact.uniq.join(', ')\n end",
"def category\n return '' if self.categories.empty?\n self.categories.join(', ')\n end",
"def categories_as_string\n categories.map(&:title).sort.join(', ')\n\n end",
"def category_name\n category.name\n end",
"def display_category(category_class)\n category_class.gsub(/ +/, ', ')\n end",
"def category_string\n return Item::ITEM_CATEGORIES[self.category_id] if self.category_id\n return \"\"\n end",
"def category_name\n I18n.t(\"feste.categories.#{category}\", default: category.titleize)\n end",
"def category\n categories.collect(&:title).join(',')\n end",
"def categoryname\n\t\t\tcategory.category_name\n\t\tend",
"def to_s( )\n\t\t\tid = 0\n\t\t\[email protected](\"\") do |disp, (name, count_or_calc)|\n\t\t\t\tif count_or_calc.is_a?(Numeric)\n\t\t\t\t\tid += 1\n\t\t\t\t\tdisp + \"%3d: %-20s %4d\\n\" % [id, name, count_or_calc]\n\t\t\t\telse\n\t\t\t\t\tdisp + \" %-20s %4d\\n\" %\n\t\t\t\t\t\t[name, count_or_calc.call(to_hash)]\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def type_category_string\n result = \"Manifestation\"\n result = \"Score\" if is_a_score?\n result = \"Recording\" if is_a_recording?\n result = \"Media on Demand\" if is_a_sounzmedia?\n result\n end",
"def categories_as_string\n categories.map(&:title).sort.join(', ')\n end",
"def tag_category_string(category, options={})\n return \"\" unless self.respond_to?(category)\n if !self.placeholder_tags.blank?\n tag_array = self.placeholder_tags[category] || []\n else\n tag_array = self.send(category)\n end\n tag_names = tag_array.map {|tag| tag.name}\n if options[:return_array]\n tag_names\n else\n tag_names.join(ArchiveConfig.DELIMITER_FOR_OUTPUT)\n end\n end",
"def category_label\n Categories::LABELS[category]\n end",
"def categorized_specific_skill\n return \"#{skill_category.description} : #{specific_skill}\"\n end",
"def category\n @category ||= ''\n end",
"def category\n if self.channel.generator == 'Twitter'\n return self.categories.join(', ')\n end\n return '' if @item.categories.empty? \n @item.categories.collect{|c| c.content}.join(', ')\n end",
"def title\n @category.split(':')[@depth-1].to_s.strip\n end",
"def categories_as_string\n categories.map(&:title).sort.join(',')\n end",
"def to_s\n x = categoria + \"\\n\"\n titles = \"#{\" \" * 21}%-10s %-10s %-10s\\n\" % [\"proteínas\", \"glúcidos\", \"lípidos\"]\n x += titles\n each do |alimento|\n x += Alimento.instance_method(:to_s).bind(alimento).call + \"\\n\"\n end\n x += \"\\n\"\n return x\n end",
"def to_s()\n \"#{item_description} - #{id_category}\"\n end",
"def category_names_string(arguments = {})\n seperator = arguments.fetch(:seperator){\", \"}\n\n self.categories.pluck(:name).join(seperator)\n end",
"def category_names\n @category_names || categories.map(&:name).join(' ')\n end",
"def get_category_notice\n notice = \"\"\n if self.category == \"1\"\n notice = \"CATEGORY 1\"\n elsif self.category == \"2\"\n notice = \"CATEGORY 2\"\n elsif self.category == \"3\"\n notice = \"CATEGORY 3\"\n elsif self.category == \"4\"\n notice = \"CATEGORY 4\"\n elsif self.category == \"5\"\n notice = \"CATEGORY 5\"\n end\n\n return notice\n end",
"def category_name\n category.name if category\n end",
"def category_term\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 3 )\n value = nil\n term10 = nil\n\n begin\n # at line 41:37: ( WS )? term\n # at line 41:37: ( WS )?\n alt_7 = 2\n look_7_0 = @input.peek( 1 )\n\n if ( look_7_0 == WS )\n alt_7 = 1\n end\n case alt_7\n when 1\n # at line 41:37: WS\n match( WS, TOKENS_FOLLOWING_WS_IN_category_term_128 )\n\n end\n @state.following.push( TOKENS_FOLLOWING_term_IN_category_term_131 )\n term10 = term\n @state.following.pop\n # --> action\n value = ( term10 && @input.to_s( term10.start, term10.stop ) ) \n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 3 )\n\n end\n \n return value\n end",
"def category_name\n category = Category.find_by_id(self.category_id)\n return category.name\n end",
"def show_category_name\n return @show_category_name\n end",
"def to_s\n label_name.to_s + ':' + rule.embed\n end",
"def format_category_name # WHY IS IT IN HERE?\n self.category.name.downcase.delete(' ')\n end",
"def category_friendly\n return self.category.gsub(/[-_]/, ' ').titleize\n end",
"def inspect\n \"#<Plaid::Category id=#{id.inspect}, type=#{type.inspect}, \" \\\n \"hierarchy=#{hierarchy.inspect}>\"\n end",
"def to_s\n label.to_s + ':' + rule.embed\n end",
"def name\n description_category\n end",
"def category\n string = Array(@data['categories'])[0]\n return '' if string.to_s.empty?\n\n string.split('/').map { |c|\n Silly::StringFormat.clean_slug_and_escape(c)\n }.join('/')\n end",
"def category_name(product)\n\t\tproduct.category ? product.category.name : \"Category not set\"\n\tend",
"def category_name\r\n category.name.titleize rescue nil\r\n end",
"def category_term\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 3 )\n value = nil\n term10 = nil\n\n begin\n # at line 68:37: ( WS )? term\n # at line 68:37: ( WS )?\n alt_7 = 2\n look_7_0 = @input.peek(1)\n\n if (look_7_0 == WS)\n alt_7 = 1\n end\n case alt_7\n when 1\n # at line 68:37: WS\n match(WS, TOKENS_FOLLOWING_WS_IN_category_term_131)\n\n end\n @state.following.push(TOKENS_FOLLOWING_term_IN_category_term_134)\n term10 = term\n @state.following.pop\n # --> action\n value = (term10 && @input.to_s(term10.start, term10.stop))\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 3 )\n\n end\n\n return value\n end",
"def to_s\n return \"#{name}: #{self.set_concept.concepts.collect{|c|c.name}}\"\n end",
"def to_s\n @s=\"Cost Breakdown: \"\n if activity_cost_category.nil?\n @s+\"<No Category>\"\n else\n @s+activity_cost_category.to_s\n end\n end",
"def category_names(categories)\n return t('challenges.no_category') if categories.empty?\n\n categories.map(&:name).join(', ')\n end",
"def getProductCategoryObjName\r\n\t\t\treturn \"mfiforce__Product_Category__c\"\r\n\t\tend",
"def category_name \n self.category ? self.category.name : nil\n end",
"def category_name \n\tself.category.name \n end",
"def get_category_and_gender_short\n \"#{get_category_type_name} #{gender_type.i18n_short}\"\n end",
"def label_for_category(category)\n CATEGORY_LABELS.fetch(category, \"~#{category}\")\n end",
"def rating_string\n tag_category_string(:ratings)\n end",
"def award_code_category\n \"#{award.name} #{code}: #{name}\"\n end",
"def full_name\n \"#{category.prefix}#{name}\"\n end",
"def category()\n if (order_in_lines.length == 1)\n cat = order_in_lines[0].book_keeping_category\n if (cat)\n return cat.name\n else\n return \"?\"\n end\n else\n return \"?\"\n end\n end",
"def categories_as_string\ncategories.map(&:title).sort.join(', ')\n end",
"def localized_category_label(category_string)\n return nil if category_string.nil?\n category_string += \"s\" if [\"item\", \"favor\"].include?(category_string)\n return t(\"listings.index.#{category_string}\")\n end",
"def categories\n category_keys.collect(&:to_s)\n end",
"def category\n \"manuscripts\"\n end",
"def category\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 1 )\n hash = nil\n category_value1 = nil\n\n begin\n # at line 53:4: 'Category' ':' category_value\n match(T__9, TOKENS_FOLLOWING_T__9_IN_category_42)\n match(T__10, TOKENS_FOLLOWING_T__10_IN_category_44)\n @state.following.push(TOKENS_FOLLOWING_category_value_IN_category_46)\n category_value1 = category_value\n @state.following.pop\n # --> action\n hash = category_value1\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 1 )\n\n end\n\n return hash\n end",
"def get_category_type_name\n category_type ? category_type.short_name : '?'\n end",
"def cats_input\n self.categories.join(\"\\n\")\nend",
"def to_citrus # :nodoc:\n rule_name.to_s\n end",
"def category_name\n parse_cookbook_json do |parsing_errors, json|\n if parsing_errors.any?\n \"\"\n else\n json.fetch(\"category\", \"\").to_s\n end\n end\n end",
"def to_s\n if label\n \"#{label}:\" + (needs_paren? ? \"(#{to_citrus})\" : to_citrus)\n else\n to_citrus\n end\n end",
"def category\n @data['category']\n end",
"def get_category_name\n Category.find(:first, :select => ['name'],:conditions=>['has_complexity=?',false]).name rescue ''\n end",
"def category= arg\n cat_arr = arg.to_s.split(':')[0..@depth-1] || []\n @category = cat_arr.join(':').to_s\n end",
"def category(value)\n merge(orcategory: value.to_s)\n end",
"def base_category_key\n [ base_key, 'cat:' ].flatten.join(':')\n end",
"def to_s\n return @labels.join('.')\n end",
"def link_category\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 16 )\n value = nil\n category_name25 = nil\n\n begin\n # at line 110:35: ';' ( WS )? 'category' '=' '\\\"' category_name '\\\"'\n match(T__11, TOKENS_FOLLOWING_T__11_IN_link_category_669)\n # at line 110:39: ( WS )?\n alt_25 = 2\n look_25_0 = @input.peek(1)\n\n if (look_25_0 == WS)\n alt_25 = 1\n end\n case alt_25\n when 1\n # at line 110:39: WS\n match(WS, TOKENS_FOLLOWING_WS_IN_link_category_671)\n\n end\n match(T__25, TOKENS_FOLLOWING_T__25_IN_link_category_674)\n match(T__13, TOKENS_FOLLOWING_T__13_IN_link_category_676)\n match(T__14, TOKENS_FOLLOWING_T__14_IN_link_category_678)\n @state.following.push(TOKENS_FOLLOWING_category_name_IN_link_category_680)\n category_name25 = category_name\n @state.following.pop\n match(T__14, TOKENS_FOLLOWING_T__14_IN_link_category_682)\n # --> action\n value = (category_name25 && @input.to_s(category_name25.start, category_name25.stop))\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 16 )\n\n end\n\n return value\n end",
"def category_prefix(category)\n symbols = case category\n when :rx then '--->'\n when :tx then '<---'\n else '----'\n end\n category.to_s.rjust(8) + \" | #{symbols} | \"\n end",
"def category\n return @category\n end",
"def category\n return @category\n end",
"def category\n return @category\n end",
"def category\n return @category\n end",
"def category\n return @category\n end",
"def category\n return @category\n end",
"def purpose\n \"Intern seeking #{category_name.capitalize} position\"\n end",
"def to_s\n (\n [\"Score #{sprintf '%0.4f', score}: \" +\n \"#{sprintf '%0.4f', phonetic_coverage} phonetic, \" +\n \"#{sprintf '%0.4f', semantic_coverage} semantic \"] +\n [\"Morphemes (#{morphemes.length})\"] + [\"-\" * \"Morphemes\".length] +\n morphemes.to_a.sort_by {|m| m.transcription} +\n [\"Word List\"] + [\"-\" * \"Word List\".length] +\n word_list\n ).join(\"\\n\")\n end",
"def to_s\n \"[(#{@word}:#{@type})]\"\n end",
"def ffck_categories_detailed()\n ['Pitchoun', 'Poussin 1', 'Poussin 2', 'Benjamin 1', 'Benjamin 2', 'Minime 1', 'Minime 2', 'Cadet 1', 'Cadet 2',\n 'Junior 1', 'Junior 2', 'Senior', 'Veteran 1', 'Veteran 2', 'Veteran 3', 'Veteran +', 'Inconnu']\n end",
"def malware_category_summary\n return @malware_category_summary\n end",
"def category\n @ole.Category\n end",
"def category_name\n !self.category.nil? ? self.category.name : \"\"\n end",
"def to_s\n 'rule: ' + @symbol.to_s\n end",
"def to_s\n\t\treturn self.words.join(\" \")\n\tend",
"def to_s\n '!' + rule.embed\n end",
"def to_s\n '!' + rule.embed\n end",
"def to_s\n rule.inspect\n end",
"def get_category_type_short_name\n category_type ? category_type.short_name : '?'\n end",
"def inspect\n [self,(\"(#{pretty_score})\" if @score),(\"(language:#{language})\" if language)].compact.join(\" \")\n end",
"def category_name\n category.try(:name)\n end",
"def to_xml \n result = String.new\n builder = Builder::XmlMarkup.new(:target => result, :indent => 2)\n \n attributes = {}\n instance_variables.each do |iv|\n attributes[iv.split(\"@\")[1]] = normalize instance_variable_get(iv)\n end\n \n builder.tag!(\"category\", attributes)\n \n result\n end",
"def to_s()\n\t\treturn \"Chapter : #{@title}, levels : #{@levels}, stars required : #{@starsRequired}\"\n\tend",
"def category13\n return @category13\n end",
"def category\n case self.scorable_type\n when \"GovernmentScore\"\n return \"Government\"\n when \"ParkScore\"\n return \"Parks\"\n when \"SchoolScore\"\n return \"Schools\"\n when \"PoliceScore\"\n return \"Police\"\n when \"PublicScore\"\n return \"Public Works\"\n end\n end",
"def to_s\n rule_name.to_s\n end",
"def category_descriptions\n return @category_descriptions\n end",
"def category18\n return @category18\n end",
"def expertise\n subcategories.map(&:name).to_sentence\n end",
"def short_name\n Category.short_name name\n end",
"def to_s\n self.description\n end",
"def to_s\n rule\n end"
] | [
"0.7226081",
"0.69705087",
"0.68056196",
"0.67046916",
"0.6691956",
"0.6684867",
"0.6640186",
"0.6604781",
"0.6555169",
"0.6547275",
"0.6545283",
"0.64379144",
"0.63994837",
"0.6389162",
"0.63754874",
"0.6367628",
"0.6335599",
"0.6310271",
"0.6302742",
"0.6287388",
"0.62440914",
"0.61912096",
"0.61264485",
"0.6107727",
"0.6063831",
"0.60571265",
"0.6048842",
"0.6041127",
"0.60397834",
"0.6033992",
"0.60273826",
"0.6022238",
"0.6022212",
"0.6010375",
"0.60096955",
"0.598666",
"0.5983163",
"0.5977362",
"0.59618735",
"0.59617925",
"0.5957037",
"0.59568006",
"0.5946757",
"0.5937956",
"0.5935504",
"0.5896854",
"0.5887547",
"0.5878025",
"0.58691925",
"0.5866415",
"0.58617306",
"0.58599204",
"0.5839523",
"0.5816742",
"0.58163303",
"0.58115244",
"0.58092",
"0.5802839",
"0.5802154",
"0.5796766",
"0.5795074",
"0.5794577",
"0.5782972",
"0.577772",
"0.5775907",
"0.57691133",
"0.5767226",
"0.5763872",
"0.57636297",
"0.57636297",
"0.57636297",
"0.57636297",
"0.57636297",
"0.57636297",
"0.57570726",
"0.57280624",
"0.5718296",
"0.5697981",
"0.56948537",
"0.56944364",
"0.5683802",
"0.5681648",
"0.56809306",
"0.56619006",
"0.56619006",
"0.5651099",
"0.564546",
"0.56350994",
"0.56315017",
"0.56187445",
"0.56157696",
"0.5605717",
"0.5605244",
"0.5602485",
"0.5592143",
"0.5591214",
"0.5589311",
"0.5588511",
"0.5584787",
"0.55844635"
] | 0.8598717 | 0 |
Returns a symbol representation of the category. | def to_sym
self.tag
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_s\n return self.symbol\n end",
"def to_s \n self.symbol\n end",
"def to_s\n \"#{symbol}\"\n end",
"def category_label\n Categories::LABELS[category]\n end",
"def to_s\n \"Grammatical category: #{self.tag} - '#{self.name}'\"\n end",
"def category_name\n category.name\n end",
"def label_for_category(category)\n CATEGORY_LABELS.fetch(category, \"~#{category}\")\n end",
"def category_prefix(category)\n symbols = case category\n when :rx then '--->'\n when :tx then '<---'\n else '----'\n end\n category.to_s.rjust(8) + \" | #{symbols} | \"\n end",
"def to_symbol\n TO_SYMBOL_MAP[@color]\n end",
"def symbol currency\n definitions[currency][:symbol]\n end",
"def category_name()\n if @handle.ptr == nil\n raise \"this is disposed\"\n end\n result = Native.Run_category_name(@handle.ptr)\n result\n end",
"def categoryname\n\t\t\tcategory.category_name\n\t\tend",
"def get_symbol_using_type(type)\n case type\n when EducationOrganizationCategoryType.to_string(:STATE_EDUCATION_AGENCY); :seas\n when EducationOrganizationCategoryType.to_string(:LOCAL_EDUCATION_AGENCY); :leas\n when SchoolCategory.to_string(:ELEMENTARY); :elementary\n when SchoolCategory.to_string(:MIDDLE); :middle\n when SchoolCategory.to_string(:HIGH); :high\n end\n end",
"def display_category(category_class)\n category_class.gsub(/ +/, ', ')\n end",
"def getProductCategoryObjName\r\n\t\t\treturn \"mfiforce__Product_Category__c\"\r\n\t\tend",
"def to_s\n if SUIT_UNICODE_OK \n return self.unicode\n else\n return self.symbol\n end \n end",
"def asm_symbol(s)\n sa = Word[s]\n return sa if !sa.nil?\n a = ['']\n s.each_char do |c|\n g = Graph[c]\n if g.nil?\n a[-1] << c\n else\n # graph char found\n if g != ''\n if a[-1] == ''\n a[-1] << g\n a << ''\n else\n a << \"#{g}\"\n a << ''\n end\n end\n end\n end\n if a[-1] == ''\n a.pop\n end\n a.join('_').downcase\n end",
"def to_sym\n @name\n end",
"def name\n [@n.to_s + character.to_s, symmetry].reject{|p| p == \"\"}.join(\"_\")\n end",
"def to_s\n to_symbol.to_s\n end",
"def to_sym() end",
"def to_sym() end",
"def to_sym() end",
"def category_term\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 3 )\n value = nil\n term10 = nil\n\n begin\n # at line 68:37: ( WS )? term\n # at line 68:37: ( WS )?\n alt_7 = 2\n look_7_0 = @input.peek(1)\n\n if (look_7_0 == WS)\n alt_7 = 1\n end\n case alt_7\n when 1\n # at line 68:37: WS\n match(WS, TOKENS_FOLLOWING_WS_IN_category_term_131)\n\n end\n @state.following.push(TOKENS_FOLLOWING_term_IN_category_term_134)\n term10 = term\n @state.following.pop\n # --> action\n value = (term10 && @input.to_s(term10.start, term10.stop))\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 3 )\n\n end\n\n return value\n end",
"def get_cyc_symbol(name=params[:id])\n CycConcept.find_by_name(name) || CycConcept.new(:name => name)\n end",
"def category_string\n return Item::ITEM_CATEGORIES[self.category_id] if self.category_id\n return \"\"\n end",
"def category_term\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 3 )\n value = nil\n term10 = nil\n\n begin\n # at line 41:37: ( WS )? term\n # at line 41:37: ( WS )?\n alt_7 = 2\n look_7_0 = @input.peek( 1 )\n\n if ( look_7_0 == WS )\n alt_7 = 1\n end\n case alt_7\n when 1\n # at line 41:37: WS\n match( WS, TOKENS_FOLLOWING_WS_IN_category_term_128 )\n\n end\n @state.following.push( TOKENS_FOLLOWING_term_IN_category_term_131 )\n term10 = term\n @state.following.pop\n # --> action\n value = ( term10 && @input.to_s( term10.start, term10.stop ) ) \n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 3 )\n\n end\n \n return value\n end",
"def to_s\n c_name\n end",
"def to_sym\n name\n end",
"def category_name\n I18n.t(\"feste.categories.#{category}\", default: category.titleize)\n end",
"def currency_symbol\n Currency.new(currency).symbol\n end",
"def category_name\n category.name if category\n end",
"def symbol\n @symbol\n end",
"def to_str\n AnchorToSymbol.rassoc(kind).first\n end",
"def symbol\n # prefer a code display value since the state name may not be unique between modules\n if [email protected]? && [email protected]?\n @codes.first.display.gsub(/\\s+/, '_').downcase.to_sym\n else\n @name.gsub(/\\s+/, '_').downcase.to_sym\n end\n end",
"def symbol\n # prefer a code display value since the state name may not be unique between modules\n if [email protected]? && [email protected]?\n @codes.first.display.gsub(/\\s+/, '_').downcase.to_sym\n else\n @name.gsub(/\\s+/, '_').downcase.to_sym\n end\n end",
"def category_name\n category = Category.find_by_id(self.category_id)\n return category.name\n end",
"def symbol\n codepoints.pack(\"U*\")\n end",
"def symbol\n \n end",
"def category_string\n categories.pluck(:name).flatten.compact.uniq.join(', ')\n end",
"def symbol\n @color == \"white\" ? @symbol = \"\\u{2658}\" : @symbol = \"\\u{265e}\"\n end",
"def inspect\r\n @symbol.inspect\r\n end",
"def symbol_suffix\n \"\"\n end",
"def show_category_name\n return @show_category_name\n end",
"def to_sym\n CODES[index]\n end",
"def to_s\n to_sym.to_s\n end",
"def category_names\n categories.map {|category| CategoryCode[category]}\n end",
"def symbol\n @color \n end",
"def category\n return '' if self.categories.empty?\n self.categories.join(', ')\n end",
"def format_category_name # WHY IS IT IN HERE?\n self.category.name.downcase.delete(' ')\n end",
"def category_in_icon_name\n case category\n when 0\n \"icon_clean\"\n when 1\n \"icon_nanny\"\n when 2\n \"icon_time\"\n when 3\n \"icon_fix\"\n else\n \"icon_clean\"\n end\n end",
"def to_sym\n @name.to_sym\n end",
"def get_category(category)\n CATEGORIES[category.downcase]\n end",
"def category\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 1 )\n hash = nil\n category_value1 = nil\n\n begin\n # at line 53:4: 'Category' ':' category_value\n match(T__9, TOKENS_FOLLOWING_T__9_IN_category_42)\n match(T__10, TOKENS_FOLLOWING_T__10_IN_category_44)\n @state.following.push(TOKENS_FOLLOWING_category_value_IN_category_46)\n category_value1 = category_value\n @state.following.pop\n # --> action\n hash = category_value1\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 1 )\n\n end\n\n return hash\n end",
"def symbol\n Util.from_bytes :symbol, value\n end",
"def sym\n @name.to_sym\n end",
"def to_sym; end",
"def base_category_key\n [ base_key, 'cat:' ].flatten.join(':')\n end",
"def category_key!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 6 )\n\n type = CATEGORY_KEY\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 131:4: 'Category'\n match( \"Category\" )\n\n \n @state.type = type\n @state.channel = channel\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 6 )\n\n end",
"def to_sym\n self\n end",
"def to_xml \n result = String.new\n builder = Builder::XmlMarkup.new(:target => result, :indent => 2)\n \n attributes = {}\n instance_variables.each do |iv|\n attributes[iv.split(\"@\")[1]] = normalize instance_variable_get(iv)\n end\n \n builder.tag!(\"category\", attributes)\n \n result\n end",
"def category()\n if (order_in_lines.length == 1)\n cat = order_in_lines[0].book_keeping_category\n if (cat)\n return cat.name\n else\n return \"?\"\n end\n else\n return \"?\"\n end\n end",
"def symbol\n :Y\n end",
"def accessory_category_identifier\n @configuration.category_identifier\n end",
"def get_category_type_name\n category_type ? category_type.short_name : '?'\n end",
"def to_symbol\n case node\n in SyntaxTree::Label[value:]\n value.chomp(\":\").to_sym\n in SyntaxTree::SymbolLiteral[value: SyntaxTree::Ident[value:]]\n value.to_sym\n in SyntaxTree::SymbolLiteral[value:]\n raise CompilationError, \"Unexpected symbol value type: #{value.inspect}\"\n else\n raise CompilationError, \"Unexpected node type: #{node.class.name}\"\n end\n end",
"def symbol; end",
"def symbol; end",
"def symbol; end",
"def symbol; end",
"def symbol; end",
"def symbol; end",
"def category\n @category ||= ''\n end",
"def to_s\n 'rule: ' + @symbol.to_s\n end",
"def symbol(color)\n hash = { white: 'B', black: 'b' }\n hash[color]\n end",
"def to_standard_cat_id(category_id)\n category_id - 2000\n end",
"def type_as_symbol\n underscore(self.type).intern\n end",
"def link_category\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 16 )\n value = nil\n category_name25 = nil\n\n begin\n # at line 110:35: ';' ( WS )? 'category' '=' '\\\"' category_name '\\\"'\n match(T__11, TOKENS_FOLLOWING_T__11_IN_link_category_669)\n # at line 110:39: ( WS )?\n alt_25 = 2\n look_25_0 = @input.peek(1)\n\n if (look_25_0 == WS)\n alt_25 = 1\n end\n case alt_25\n when 1\n # at line 110:39: WS\n match(WS, TOKENS_FOLLOWING_WS_IN_link_category_671)\n\n end\n match(T__25, TOKENS_FOLLOWING_T__25_IN_link_category_674)\n match(T__13, TOKENS_FOLLOWING_T__13_IN_link_category_676)\n match(T__14, TOKENS_FOLLOWING_T__14_IN_link_category_678)\n @state.following.push(TOKENS_FOLLOWING_category_name_IN_link_category_680)\n category_name25 = category_name\n @state.following.pop\n match(T__14, TOKENS_FOLLOWING_T__14_IN_link_category_682)\n # --> action\n value = (category_name25 && @input.to_s(category_name25.start, category_name25.stop))\n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 16 )\n\n end\n\n return value\n end",
"def category_name\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 36 )\n return_value = CategoryNameReturnValue.new\n\n # $rule.start = the first token seen before matching\n return_value.start = @input.look\n\n begin\n # at line 158:18: uri\n @state.following.push(TOKENS_FOLLOWING_uri_IN_category_name_1251)\n uri\n @state.following.pop\n # - - - - - - - rule clean up - - - - - - - -\n return_value.stop = @input.look(-1)\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 36 )\n\n end\n\n return return_value\n end",
"def short_name\n Category.short_name name\n end",
"def to_s( )\n\t\t\tid = 0\n\t\t\[email protected](\"\") do |disp, (name, count_or_calc)|\n\t\t\t\tif count_or_calc.is_a?(Numeric)\n\t\t\t\t\tid += 1\n\t\t\t\t\tdisp + \"%3d: %-20s %4d\\n\" % [id, name, count_or_calc]\n\t\t\t\telse\n\t\t\t\t\tdisp + \" %-20s %4d\\n\" %\n\t\t\t\t\t\t[name, count_or_calc.call(to_hash)]\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def category_name \n\tself.category.name \n end",
"def to_s\n \"#{codepoint} (#{name})\"\n end",
"def category\n categories.collect(&:title).join(',')\n end",
"def tag_category_string(category, options={})\n return \"\" unless self.respond_to?(category)\n if !self.placeholder_tags.blank?\n tag_array = self.placeholder_tags[category] || []\n else\n tag_array = self.send(category)\n end\n tag_names = tag_array.map {|tag| tag.name}\n if options[:return_array]\n tag_names\n else\n tag_names.join(ArchiveConfig.DELIMITER_FOR_OUTPUT)\n end\n end",
"def to_sym\n to_s.to_sym\n end",
"def symbol \n return \"♚\" if @color == :black \n return \"♔\" if @color == :white\n end",
"def category_name\r\n category.name.titleize rescue nil\r\n end",
"def get_category_name\n Category.find(:first, :select => ['name'],:conditions=>['has_complexity=?',false]).name rescue ''\n end",
"def get_category_type_short_name\n category_type ? category_type.short_name : '?'\n end",
"def category_collection_key\n [ base_key, 'category' ].compact.join(':')\n end",
"def category\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 1 )\n hash = nil\n category_value1 = nil\n\n begin\n # at line 26:4: CATEGORY_KEY COLON category_value\n match( CATEGORY_KEY, TOKENS_FOLLOWING_CATEGORY_KEY_IN_category_39 )\n match( COLON, TOKENS_FOLLOWING_COLON_IN_category_41 )\n @state.following.push( TOKENS_FOLLOWING_category_value_IN_category_43 )\n category_value1 = category_value\n @state.following.pop\n # --> action\n hash = category_value1 \n # <-- action\n\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 1 )\n\n end\n \n return hash\n end",
"def symbol\n sub_str = @sub ? \"b\" : \"\"\n chord_str = @@chord_symbols[@mode][@step]\n modifiers_str = @modifiers.empty? ? \"\" : \"-#{@modifiers * \"-\"}\"\n inversion_str = @inversion > 1 ? \"_#{@inversion}\" : \"\"\n \n \"#{sub_str}#{chord_str}#{modifiers_str}#{inversion_str}\".intern\n end",
"def category(value)\n merge(orcategory: value.to_s)\n end",
"def category_name\n category.try(:name)\n end",
"def symbol_key(x)\n key = x.dup\n key.traverse do |n|\n next unless n.name == \"math\"\n n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))\n end\n ret = Nokogiri::XML(key.to_xml)\n HTMLEntities.new.decode(ret.text.downcase).\n gsub(/[\\[\\]\\{\\}<>\\(\\)]/, \"\").gsub(/\\s/m, \"\").\n gsub(/[[:punct:]]|[_^]/, \":\\\\0\").gsub(/`/, \"\").\n gsub(/[0-9]+/, \"þ\\\\0\")\n end",
"def to_sym\r\n self.class.to_s.to_sym\r\n end",
"def symbol_key(x)\n HTMLEntities.new.decode(x.text).gsub(/_/, \":\").gsub(/`/, \"\").\n gsub(/[0-9]+/, \"þ\\\\1\")\n end",
"def category11\n return @category11\n end",
"def symbol\n :R\n end"
] | [
"0.6498329",
"0.6364069",
"0.6353104",
"0.62913716",
"0.6284162",
"0.6265759",
"0.6264143",
"0.6169924",
"0.5931704",
"0.593073",
"0.59150445",
"0.5910688",
"0.59010756",
"0.5880927",
"0.58337337",
"0.58181757",
"0.5805329",
"0.57892",
"0.5781974",
"0.5767561",
"0.5740013",
"0.5740013",
"0.5740013",
"0.5736812",
"0.5736427",
"0.57352495",
"0.5725463",
"0.5707429",
"0.5671446",
"0.5631644",
"0.56304103",
"0.56287307",
"0.56137884",
"0.56133354",
"0.5600847",
"0.5600847",
"0.5599008",
"0.55982476",
"0.55934656",
"0.5583879",
"0.5582728",
"0.55647564",
"0.55502766",
"0.5545166",
"0.5539431",
"0.55370533",
"0.5514889",
"0.5508024",
"0.55031794",
"0.549967",
"0.54966104",
"0.5480362",
"0.5470646",
"0.54645854",
"0.54577094",
"0.54495305",
"0.5449413",
"0.5447128",
"0.5439846",
"0.54393595",
"0.543568",
"0.5430389",
"0.5430033",
"0.5429241",
"0.5427545",
"0.54123557",
"0.540509",
"0.540509",
"0.540509",
"0.540509",
"0.540509",
"0.540509",
"0.5400321",
"0.53997266",
"0.53990215",
"0.53947204",
"0.53890175",
"0.53796226",
"0.53791636",
"0.5377119",
"0.5376129",
"0.5375314",
"0.53654623",
"0.5360233",
"0.53593713",
"0.53447986",
"0.53398687",
"0.5335446",
"0.5330281",
"0.53264034",
"0.5324357",
"0.53223914",
"0.5312673",
"0.53051615",
"0.5302226",
"0.52956575",
"0.52916527",
"0.52914965",
"0.52813977",
"0.52781993"
] | 0.5877217 | 14 |
============================================================================== bench methods ============================================================================== note : pre db.clear and post db.close are included. | def rufus_cabinet_bench (bench_title, db)
db.clear
2.times { puts }
puts bench_title
Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|
b.report('inserting one') do
db['a'] = 'A'
end
b.report('inserting N') do
N.times { |i| db["key #{i}"] = "value #{i}" }
end
b.report('finding all keys') do
db.keys
end
unless db.class.name.match(/^Rufus::Edo::/)
b.report('finding all keys (native)') do
db.keys(:native => true).free
end
end
b.report('finding all keys (pref)') do
db.keys(:prefix => 'key ')
end
b.report('finding all keys (r pref)') do
db.keys.select { |k| k[0, 4] == 'key ' }
end
b.report('finding all') do
db.values
end
b.report('iterate all') do
db.each { |k, v| }
end
b.report('find first') do
db["key #{0}"]
end
b.report('delete first') do
db.delete("key #{0}")
end
txt = 'delete_keys_with_prefix "1"'
txt += ' (M)' if db.class.name == 'Rufus::Edo::Cabinet'
b.report(txt) do
db.delete_keys_with_prefix('key 1')
end
b.report('del keys with prefix "2" (m)') do
ks = db.keys(:prefix => 'key 2')
ks.each { |k| db.delete(k) }
end
end
db.close
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flushdb; end",
"def teardown\n @db.close\n super\n end",
"def close_database\n @database = nil\n @writable_database = nil\n GC.start\n end",
"def close_database\n @database = nil\n @writable_database = nil\n GC.start\n end",
"def flushdb\n end",
"def close()\n @db.close()\n end",
"def close\n @db.close\n end",
"def flushdb(options = T.unsafe(nil)); end",
"def close\n db.close\n end",
"def close\n @dbman.close\n @dbprot.clear\n end",
"def close\n @db.close if @db && !(@db.closed?)\n self\n end",
"def close\n lib.tcidbclose( @db ) || raise_error\n\n lib.tcidbdel( @db )\n\n @db = nil\n end",
"def clear\n @db.clear\n self\n end",
"def rufus_table_bench (bench_title, db)\n\n 2.times { puts }\n puts bench_title\n\n Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|\n\n db.clear\n\n db.clear\n db.set_index('name', :lexical)\n\n b.report('inserting data (index set)') do\n DATA1.each_with_index { |e, i| db[\"key #{i.to_s}\"] = e }\n end\n\n db.clear\n db.set_index('name', :remove)\n\n b.report('inserting data (no index)') do\n DATA1.each_with_index { |e, i| db[\"key #{i.to_s}\"] = e }\n end\n\n b.report('finding all keys') do\n db.keys\n end\n b.report('finding all keys (pref)') do\n db.keys(:prefix => 'key ')\n end\n b.report('finding all keys (r pref)') do\n db.keys.select { |k| k[0, 4] == 'key ' }\n end\n b.report('finding all') do\n db.query { |q| }\n end\n b.report('find last') do\n db[\"key #{DATA.size.to_s}\"]\n end\n b.report('delete last') do\n db.delete(\"key #{DATA.size.to_s}\")\n end\n b.report('find Alphonse') do\n db.query { |q| q.add('name', :equals, DATA1[0]['name']) }\n end\n\n b.report(\"setting index (#{DATA.size} rows)\") do\n db.set_index('name', :lexical)\n end\n\n b.report('find Alphonse (index set)') do\n db.query { |q| q.add('name', :equals, DATA1[0]['name']) }\n end\n\n b.report('delete_keys_with_prefix \"1\"') do\n db.delete_keys_with_prefix('key 1')\n end\n #b.report('del keys with prefix \"2\" (m)') do\n # ks = db.keys(:prefix => 'key 2')\n # ks.each { |k| db.delete(k) }\n #end\n end\n\n db.close\nend",
"def teardown\n teardown_db\n end",
"def close\n @database.close if @database\n end",
"def close\n @database.close if @database\n end",
"def clear_db\n @@db.clear_db\n end",
"def flushdb\n redis.flushdb\n end",
"def test_manipulate_databases\n number=1000\n relation_name = \"Dog\"\n relation_schema = {\"name\" => \"string\", \"race\" => \"string\", \"age\" => \"integer\"}\n values = {\"name\" => \"Bobby\", \"age\" => 2, \"race\"=> \"labrador\"}\n @dbids.each do |id|\n database(id).create_relation(relation_name,relation_schema)\n assert_equal(\"Dog\",database(id).relation_classes[\"Dog\"].table_name)\n end\n \n @dbids.each do |id|\n puts \"insert into db : #{id}\"\n\n (0..number).each do |i|\n count_values = {\"name\" => \"Bobby#{i}\", \"age\" => i, \"race\"=> \"labrador\"}\n database(id).relation_classes[\"Dog\"].insert(count_values)\n end\n assert_equal(number+1,database(id).relation_classes[\"Dog\"].all.size)\n\n end\n \n @dbids.each do |id|\n number_of_tuples_to_delete = rand(number)\n (1..number_of_tuples_to_delete).each do |i|\n database(id).relation_classes[\"Dog\"].delete(i)\n end\n assert_equal(number+1-number_of_tuples_to_delete,database(id).relation_classes[\"Dog\"].all.size)\n end\n \n end",
"def db_remove!( db_file )\n ####db = SQLite3::Database.new( db_file )\n ####db.execute( db_remove )\n ####db.close \n puts \"SQLite3\"\n end",
"def flush_db\n [ 'active_sources', 'data_records', 'semantic_properties', 'semantic_relations', 'workflows'].reverse.each { |f| ActiveRecord::Base.connection.execute \"DELETE FROM #{f}\" }\n # Also remove the \"unsaved cache\" for the wrappers (may be important during testing)\n TaliaCore::SemanticCollectionWrapper.instance_variable_set(:'@unsaved_source_cache', {})\n end",
"def reset_db\n \n end",
"def close_connection\n @db.close if @db\n end",
"def close\n\n @db.connection.close\n end",
"def clear\n lib.tcidbvanish( @db )\n end",
"def flush\n t = Time.now.to_i - 100\n sql_str = \"DELETE FROM UserQualities WHERE date < #{t}\"\n a = DATABASE.execute(\"SELECT COUNT (id) FROM UserQualities\") #debug purposes\n #binding.pry\n DATABASE.execute(sql_str)\n b = DATABASE.execute(\"SELECT COUNT (id) FROM UserQualities\") #debug purposes\n puts \"FLUSHED #{a[0][0]-b[0][0]} of #{a[0][0]} USER QUALITIES\" #debug\n end",
"def clear\n instrument(:clear, nil, nil) do\n failsafe(:clear) do\n with(&:flushdb)\n end\n end\n end",
"def flushdb\n @redis.flushdb\n end",
"def limited_bench (bench_title, db)\n\n 2.times { puts }\n puts bench_title\n\n Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|\n\n b.report('inserting one') do\n db['a'] = 'A'\n end\n b.report('inserting N') do\n N.times { |i| db[\"key#{i}\"] = \"value #{i}\" }\n end\n b.report('find first') do\n db[\"key#{0}\"]\n end\n b.report('delete first') do\n db.delete(\"key#{0}\")\n end\n end\nend",
"def flushdb\n on_each_node :flushdb\n end",
"def database_reset\n @database = nil\n end",
"def db_close\n @dbh and @dbh.close\n @dbh = nil\n end",
"def db_close\n @dbh and @dbh.close\n @dbh = nil\n end",
"def cursor_close_test(read=:primary)\n insert_docs\n 10.times do\n cursor = @coll.find({}, :read => read)\n cursor.next\n assert cursor.instance_variable_get(:@pool)\n assert cursor.alive?\n cursor.close\n end\n end",
"def shutdown\n\n @db.connection.close\n end",
"def flushdb\n\t\t\[email protected]\n\t\t\[email protected](\"Flushing database\")\n\t\tend",
"def clear_db\n\t\tdb = SQLite3::Database.open \"simpl.db\"\n\t\tdb.execute \"DELETE FROM user;\"\n\t\tdb.execute \"DELETE FROM merchant;\"\n\t\tdb.execute \"DELETE FROM transactions;\"\n\tend",
"def clear_db\n\t\tdb = SQLite3::Database.open \"simpl.db\"\n\t\tdb.execute \"DELETE FROM user;\"\n\t\tdb.execute \"DELETE FROM merchant;\"\n\t\tdb.execute \"DELETE FROM transactions;\"\n\tend",
"def clear_db\n clear_urls + clear_docs\n end",
"def close\n @tc_bdb.close\n @tc_bdbcur = nil\n end",
"def endRun\n db_cached_connect\n\n @dbh.do(\"SELECT endRun();\")\n @dbh.do(\"COMMIT TRANSACTION;\")\n end",
"def hard_clean!\n open_db\n @file.truncate(PREAMBLE_SIZE)\n write_fresh_database\n end",
"def db; end",
"def db; end",
"def clear_db()\n ScraperWiki.sqliteexecute('DELETE FROM event')\nend",
"def clear_db()\n ScraperWiki.sqliteexecute('DELETE FROM event')\nend",
"def clean_db\n\n puts \"Caching wikipedia links\"\n @wikipedia_cache = {}\n Artist.all\n .where('wikilink IS NOT NULL')\n .pluck( 'name' , 'wikilink' )\n .each { |result| @wikipedia_cache[ key_name(result[0]) ] = result[1] }\n\n puts \"Cleaning db\"\n PlayerState.delete_all\n PlayListSong.delete_all\n Song.delete_all\n Album.delete_all\n Artist.delete_all\n end",
"def teardown\n\t\tActiveRecord::Base.clear_all_connections!\n\t\t#File.delete \"test.sqlite\"\n\tend",
"def clear\n run_hook(:before_clear)\n db.clear\n run_hook(:after_clear)\n end",
"def flushall; end",
"def commit\n # Nothing to do for an in memory database\n end",
"def close\n @mysql.close\n @mysql = nil\n end",
"def db_setup\n log_debug\n db_file = find_db\n db_tmp = '/tmp/plex_missing_tmp.db'\n @db = ''\n \n # cp to tmp as the db is locked if being used\n `cp \"#{db_file}\" #{db_tmp}`\n \n # not too sure why but i was having a problem where a 0 byte file was cp'd\n # def a local issue i assume but the check was needed\n if test ?s, db_tmp\n @db = SQLite3::Database.new db_tmp\n else \n puts \"error-> can not open #{db_tmp} for reasing\"\n exit 2\n end\n end",
"def flush()\n #This is a stub, used for indexing\n end",
"def reinitialize_db\n drop_db\n initialize_db\n end",
"def shutdown(this_db = @db)\n this_db.shutdown if this_db\n end",
"def shutdown(this_db = @db)\n this_db.shutdown if this_db\n end",
"def benchmark_db(crud_operation, model)\n if @stats_client\n @stats_client.db_call { yield }\n else\n yield\n end\n end",
"def exit\n if @cache && @cache.in_transaction?\n @cache.abort_transaction\n @cache.flush\n @db.close if @db\n PEROBS.log.fatal \"You cannot call exit() during a transaction: #{Kernel.caller}\"\n end\n @cache.flush if @cache\n @db.close if @db\n\n GC.start\n if @stats\n unless @stats[:created_objects] == @stats[:collected_objects] +\n @in_memory_objects.length\n PEROGS.log.fatal \"Created objects count \" +\n \"(#{@stats[:created_objects]})\" +\n \" is not equal to the collected count \" +\n \"(#{@stats[:collected_objects]}) + in_memory_objects count \" +\n \"(#{@in_memory_objects.length})\"\n end\n end\n\n @db = @class_map = @in_memory_objects = @stats = @cache =\n @root_objects = nil\n end",
"def close\n SQLite::API.close( @handle )\n @closed = true\n end",
"def disconnect_and_quit\n $db.close\n puts \"Closing DB. Bye!\"\n exit\nend",
"def final\n @DB.close\n # Remove eventually temporary file\n if (@TmpFileName != nil)\n File.unlink(@TmpFileName)\n end\n end",
"def clear!(db_as_well=true)\n Document.destroy_all if db_as_well\n close\n Dir.glob(File.join(Picolena::IndexSavePath,'**/*')).each{|f| FileUtils.rm(f) if File.file?(f)}\n end",
"def clear\n\t\t@data_base = {}\n\t\tupdate_database\n\tend",
"def clear(options = nil)\n @data.flushdb\n end",
"def flushdb\n with_failover { redis.flushdb }\n end",
"def release\n chk_conn\n @connected = false\n @db.release(self)\n end",
"def closeDBConn()\n if ( !@db_conn.nil? )\n begin\n @db_conn.finish()\n rescue Exception => e\n #ignore it\n end\n end\n end",
"def close\n # by default do nothing - close any cached connections\n end",
"def setup_test_database\n connection = PG.connect(dbname: 'chitter_challenge_test')\n connection.exec(\"TRUNCATE peeps;\")\nend",
"def set_up_test_database \n connection = PG.connect(dbname: 'chitter_peeps_test')\n #clear the peeps table\n connection.exec(\"TRUNCATE peeps;\")\nend",
"def update_db\n ## Sequel\n drop_table\n create_table\n db.transaction do\n table.delete_sql\n install_manual\n install_updates\n end\n ## AR\n # self.transaction do\n # self.delete_all\n # self.install_manual\n # self.install_updates\n # end\n end",
"def teardown\n @mem.mem_clear\n end",
"def sqlite(dbname)\n db = SQLite3::Database.new dbname + '.sqlite3'\n yield db\n db.close\nend",
"def flush!\n @redis.flushdb\n end",
"def dbsize; end",
"def dbsize; end",
"def test_DB_initialization\n @fdb = setup\n assert(@fdb.size > 0, \"Database entries not correctly read in\")\n end",
"def teardown\n cleanup_tables\n cleanup_caches\n end",
"def test_for_empty_DB\n\t\tputs \"TEST 1\"\n\t\tassert( @db.empty? , \"DB is not empty\")\n\tend",
"def commit_db_transaction() end",
"def commit_db_transaction() end",
"def test_garbage_collection\n 50.times do\n l = Lua::State.new\n g = l.__globals\n l = g = nil\n GC.start\n end\n end",
"def query_db(sql)\n pp sql\n db = SQLite3::Database.new('database.db')\n db.results_as_hash = true\n data = db.execute(sql)\n db.close\n data\nend",
"def setup\n clear_db\n\n @db = Wgit::Database.new\n end",
"def flush_database\n\t\t\tp \"Flushing Database\"\n\t\t\tAdmin.destroy_all\n\t\t\tCountry.destroy_all\n\t\t\tDoorkeeper::Application.destroy_all\n\t\tend",
"def close\n IBM_DB.close(@conn)\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each {|x| x.delete_all}\n end",
"def quit\n @watch.quit # <-- should close all the files\n # and that should allow the sincedb_write to succeed if it could not before\n _sincedb_write\n end",
"def thelper_dc_clean_wrapper\n DatabaseCleaner.clean()\n end",
"def clear\n @redis.flushdb\n end",
"def test_double_close()\n conn = Scalaroid::TransactionSingleOp.new()\n conn.close_connection()\n conn.close_connection()\n end",
"def setup ()\n db = HTPH::Hathidb::Db.new();\n @conn = db.get_conn();\n @bench = HTPH::Hathibench::Benchmark.new();\n last_id_sql = \"SELECT LAST_INSERT_ID() AS id\";\n str_exist_sql = \"SELECT id, str FROM hathi_str WHERE str = ?\";\n str_insert_sql = \"INSERT INTO hathi_str (str) VALUES (?)\";\n hathi_gd_insert_sql = \"INSERT INTO hathi_gd (gov_doc, file_id, lineno, mongo_id, hashsum, record_id, item_id) VALUES (?, ?, ?, ?, ?, ?, ?)\";\n input_select_sql = \"SELECT id FROM hathi_input_file WHERE file_path = ?\";\n input_insert_sql = \"INSERT INTO hathi_input_file (file_path, date_read) VALUES (?, SYSDATE())\";\n\n @last_id_q = @conn.prepare(last_id_sql);\n @str_exist_q = @conn.prepare(str_exist_sql);\n @str_insert_q = @conn.prepare(str_insert_sql);\n @hathi_gd_insert_q = @conn.prepare(hathi_gd_insert_sql);\n @input_select_q = @conn.prepare(input_select_sql);\n @input_insert_q = @conn.prepare(input_insert_sql);\n\n @sha_digester = Digest::SHA256.new();\n\n @loadfiles = {}; # Write tab-delim data, and when all is done, load into table.\n %w[isbn issn lccn oclc title enumc pubdate publisher sudoc].each do |suffix|\n @loadfiles[suffix] = HTPH::Hathidata::Data.new(\"#{suffix}.dat\");\n end\n\n @infile_cache = {};\nend",
"def flush\n return nil if @queries.empty?\n \n @args[:db].transaction do\n @queries.shift(1000).each do |str|\n STDOUT.print \"Executing via buffer: #{str}\\n\" if @debug\n @args[:db].q(str)\n end\n end\n \n return nil\n end",
"def clean\n\t\t\n\t\[email protected] 'twitter'\n\t\[email protected] 'rpg'\n\t\n\tend",
"def db_cleaner\n JSON.parse(params[:mongified_data][:data]).each do |data|\n data[\"lob\"] = params[:mongified_data][:lob]\n @client.destroy(data)\n end\n end",
"def delete_all\n begin\n db.execute \"TRUNCATE TABLE #{table}\"\n\n rescue SQLite3::Exception => e\n puts \"Database Exception occured\"\n puts e\n \n ensure\n db.close if db\n end\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each(&:delete_all)\n end",
"def close(save=true)\n raise InvalidDbError if @stale\n\n if save && staging?\n self.staging.write\n end\n unstage\n @stale = true\n\n # TODO: remove all locks etc\n end"
] | [
"0.7380121",
"0.6886238",
"0.6855445",
"0.6855445",
"0.68533057",
"0.6840378",
"0.6751368",
"0.66847813",
"0.6566881",
"0.65323424",
"0.64841413",
"0.641949",
"0.6387517",
"0.63486296",
"0.63454753",
"0.63007295",
"0.63007295",
"0.62566835",
"0.6255936",
"0.62432283",
"0.62383115",
"0.622172",
"0.6219121",
"0.6197041",
"0.6179689",
"0.61589104",
"0.6152072",
"0.6143705",
"0.6131395",
"0.6112301",
"0.6093887",
"0.60866994",
"0.6079458",
"0.6079458",
"0.60658073",
"0.6065395",
"0.6057887",
"0.60515434",
"0.60515434",
"0.6045622",
"0.6036797",
"0.60311544",
"0.60202295",
"0.5983643",
"0.5983643",
"0.59639513",
"0.59639513",
"0.59599936",
"0.59498435",
"0.59472984",
"0.594158",
"0.5939578",
"0.58932894",
"0.5873758",
"0.58719206",
"0.58677435",
"0.5867097",
"0.5867097",
"0.5829305",
"0.578674",
"0.5755042",
"0.57305515",
"0.57054025",
"0.56846404",
"0.5683008",
"0.56706256",
"0.56655127",
"0.56521094",
"0.5643098",
"0.5627779",
"0.5627568",
"0.5609551",
"0.5609125",
"0.5596653",
"0.55954295",
"0.5576817",
"0.5569424",
"0.5569424",
"0.55589586",
"0.55579305",
"0.55533785",
"0.55532146",
"0.55532146",
"0.5553102",
"0.5538351",
"0.5529994",
"0.5517922",
"0.55168724",
"0.550996",
"0.55059373",
"0.55030864",
"0.5500146",
"0.5494849",
"0.5490914",
"0.5484213",
"0.5475356",
"0.54748356",
"0.5471281",
"0.5468321",
"0.54656065"
] | 0.5651084 | 68 |
Tokyo Cabinet tables only do strings = memcache === tiny test for memcache_client gem note : space is an illegal char in keys here ! | def limited_bench (bench_title, db)
2.times { puts }
puts bench_title
Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|
b.report('inserting one') do
db['a'] = 'A'
end
b.report('inserting N') do
N.times { |i| db["key#{i}"] = "value #{i}" }
end
b.report('find first') do
db["key#{0}"]
end
b.report('delete first') do
db.delete("key#{0}")
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_store_type\n \"memcache\"\n end",
"def get_memcache_key_object\n MemcacheKey.new('aml.all_aml_match')\n end",
"def cached?(key)\n not @memcache.get(key).nil?\n end",
"def get_memcache_key_object\n MemcacheKey.new('aml.aml_search')\n end",
"def short_name\n 'Memcache'\n end",
"def test_set_key_value\n result = @cache.set('Key', 'Data', 0, Time.now.to_i + 60)\n cache = @cache.get('Key').args\n\n assert_true result.success\n assert_equal 'STORED', result.message.chomp.split(\"\\s\")[0]\n assert_equal 'Data', cache.data\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('client.address')\n end",
"def cache_store_type\n \"memory\"\n end",
"def get_by_ued_memcache_key_object\n MemcacheKey.new('user.user_kyc_comparison_detail')\n end",
"def cache_generate(cache_key); ::Regexp.closed_match(cache_key); end",
"def test_it_can_handle_keys_longer_than_250_characters\n long_key = 'a' * 260\n assert store.write(long_key, 123)\n assert_equal 123, store.read(long_key)\n end",
"def cached?(key)\n false\n end",
"def clear_cache_like *keys\n keys.each do |key|\n if key.is_a? Array\n cache_pool.keys.each do |k|\n k.is_a?(Array) &&\n k.size >= key.size &&\n k.slice(0, key.size) == key &&\n cache_pool.delete(k)\n end\n elsif key.is_a? Regexp\n cache_pool.keys.each do |k|\n (\n (k.is_a?(String) && k =~ key) ||\n (k.is_a?(Symbol) && k.to_s =~ key) \n ) && cache_pool.delete(k)\n end\n else\n raise \"#%s only accepts arrays and regexps\" % __method__\n end\n end\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('client.token_details')\n end",
"def test_get_non_existing\n result = @cache.get('non_existing')\n\n assert_false result.success\n assert_nil result.args\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('manager.devices')\n end",
"def cache_store_type\n \"dummy\"\n end",
"def check_cache(type, id)\n end",
"def check_cache(type, id)\n end",
"def should_cache?(key_with_locale, options, had_key)\n if had_key\n return false unless options[:default] && !options[:default].is_a?(Array)\n end\n\n _, key_without_locale = ::Lit::Cache.split_key(key_with_locale)\n return false if is_ignored_key(key_without_locale)\n\n true\n end",
"def string_include_key?(string, key)\n \nend",
"def string_include_key?(string, key)\n \nend",
"def string_include_key?(string, key)\n \nend",
"def cache_key; @cache.to_sym; end",
"def test_sanity_check_on_deleted_key\n assert(IdentityCache::DELETED.is_a?(Symbol))\n end",
"def [] string\n return unless @cache_on\n @mutex.synchronize { @cache[string] }\n end",
"def formatted_cache_data\n {\n id: id,\n client_id: client_id,\n name: name,\n symbol: symbol,\n conversion_factor: conversion_factor.present? ? conversion_factor.to_s : conversion_factor, # should be string as it goes to FE\n decimal: decimal,\n status: status,\n stake_currency_id: stake_currency_id,\n properties: properties.present? ? Token.get_bits_set_for_properties(properties) : [],\n }\n end",
"def use_table?()\n return key =~ /_T$/\n end",
"def cached? *key\n @cache.has_key? key\n end",
"def cache_key(search_string)\n \"_key_#{search_string}\"\n end",
"def test_delete_existing\n @cache.add('Key', 'Data_to_delete', 0, Time.now.to_i + 60)\n result = @cache.delete('Key')\n retrieval = @cache.get('Key')\n\n assert_true result.success\n assert_equal 'SUCCESS', result.message.chomp.split(\"\\s\")[0]\n assert_false retrieval.success\n assert_equal 'NOT_FOUND', retrieval.message.chomp.split(\"\\s\")[0]\n end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('client.api_credentials')\n end",
"def test_invalid_command_name\n command_name = 'invalid_command_name'\n socket.puts \"#{command_name} #{key} #{flags} #{exptime} #{value.length}#{Memcached::CMD_ENDING}\"\n assert_equal Memcached::INVALID_COMMAND_NAME_MSG, read_reply\n\n assert_get key, Memcached::END_MSG\n end",
"def test_ruby_264\n assert @cluster.keyspace('simplex').has_table?('rb264')\n table_meta = @cluster.keyspace('simplex').table('rb264')\n assert(!table_meta.options.compact_storage?)\n end",
"def _cache_key(*keys)\n # monkey patch to avoid SystemStackError: stack level too deep \n if keys.to_s.include?(\"i18n_transliterate_rule\")\n keys.to_s\n else\n keys.map(&:to_s).join(\" \").parameterize.underscore \n end \n end",
"def cache_get(key)\n data = @memcache.get(key)\n Merb.logger.info(\"cache: #{data.nil? ? \"miss\" : \"hit\"} (#{key})\")\n data\n end",
"def test_ttl_eviction_on_access\n @cache.store(:a, 1)\n @cache.store(:b, 2)\n\n Timecop.freeze(Time.now + 330)\n\n @cache.store(:c, 3)\n\n assert_equal({ c: 3 }, @cache.raw[:cache])\n end",
"def check_cache(type, id)\n end",
"def normalized_cache_key(sql)\n \"influxer:#{sql.gsub(/\\s*/, '')}\"\n end",
"def test_builtin_features\n cache = Cache.new(NullCache, [])\n assert_raises(ReturnFalse) { cache.find('thread') }\n assert_raises(ReturnFalse) { cache.find('thread.rb') }\n assert_raises(ReturnFalse) { cache.find('enumerator') }\n assert_raises(ReturnFalse) { cache.find('enumerator.so') }\n assert_raises(ReturnFalse) { cache.find('enumerator.bundle') }\n\n refute(cache.find('thread.bundle'))\n refute(cache.find('enumerator.rb'))\n refute(cache.find('encdb.bundle'))\n end",
"def initialize_memcache\n require 'memcache'\n memcache_options = {\n :c_threshold => 10_000,\n :compression => true,\n :debug => false,\n :namespace => 'backgroundrb_result_hash',\n :readonly => false,\n :urlencode => false\n }\n @cache = MemCache.new(memcache_options)\n @cache.servers = BackgrounDRb::BDRB_CONFIG[:memcache].split(',')\n end",
"def cache_store; end",
"def cache_store; end",
"def memcache_key_object\n @m_k_o ||= MemcacheKey.new('ost_price_points.chain_specific')\n end",
"def status_cache_key\n [\n ip,\n ip_port,\n outlet,\n secondary_outlet,\n # Include username/password so that if one of the shared schedule is right and\n # the other is wrong we still do multiple queries: one gets an error and the other\n # doesn't.\n username,\n password,\n ]\n end",
"def get(*keys)\n unless keys.length == @num_keys\n arg_count = keys.length\n fail \"Opscode::Rackspace::Monitoring::CMCache.get: Key count mismatch (#{@num_keys}:#{arg_count})\"\n end\n\n unless defined?(@cache)\n return nil\n end\n\n eval_str = '@cache'\n (0...@num_keys).each do |i|\n key = keys[i]\n cval = eval(eval_str)\n unless cval.key?(key.to_s)\n return nil\n end\n\n eval_str += \"[\\\"#{key}\\\"]\"\n end\n\n Chef::Log.debug(\"Opscode::Rackspace::Monitoring::CMCache.get: Returning cached value from #{eval_str}\")\n return eval(eval_str)\n end",
"def cache_key\n end",
"def cache_key(id); end",
"def key\n :cache\n end",
"def cache_data?(key, obj)\n if(data = @redis.get(key)).nil? # this data is a json\n\n\t\t\tdata = historical_run(key, obj.map()).to_json\n @redis.set(key, data) # redis must cache a json\n @redis.expire(key,14400)\n\t\tend\n\n return JSON.parse(data) # this data must be changed to object\n end",
"def cache_setup(hostname, username, appname, cachename)\n @namespace = [hostname, username, appname, cachename].compact.join(':')\n\n # Create the table if it's not there yet\n if !options[:connection].table_exists?(options[:table])\n options[:connection].create_table(\n options[:table]) do\n primary_key :id\n String :key , :null => false, :unique => true\n String :value, :text => true\n Time :expires\n end\n end\n\n @dataset = options[:connection][options[:table].to_sym]\n end",
"def cache_setup(hostname, username, appname, cachename)\n @namespace = [hostname, username, appname, cachename].compact.join(':')\n\n # Create the table if it's not there yet\n if !options[:connection].table_exists?(options[:table])\n options[:connection].create_table(\n options[:table]) do\n primary_key :id\n String :key , :null => false, :unique => true\n String :value, :text => true\n Time :expires\n end\n end\n\n @dataset = options[:connection][options[:table].to_sym]\n end",
"def invalidateCache()\n begin\n return @db.execute(\"DELETE FROM cache WHERE key LIKE '/%'\")\n rescue => error\n puts error\n end\n end",
"def make_cache\n if !@thread_safe \n @@c = {}\n elsif defined?(ThreadSafe)\n @@c = ThreadSafe::Hash.new\n else\n raise 'ThreadSafe is required to use the Memory cache.'\n end \n end",
"def test_can_retrieve_quoted_table_metadata\n # Check upper-case chars, unescaped upper-case chars, quoted numbers, quoted identifier with single quote,\n # quoted identifier with double quotes\n @session.execute(\"CREATE TABLE roles (\\\"FOO\\\" text, BAR ascii, \\\"10\\\" int, \\\"'20'\\\" int, \\\"\\\"\\\"30\\\"\\\"\\\" int,\n \\\"f00\\\"\\\"b4r\\\" text, PRIMARY KEY (\\\"FOO\\\", BAR, \\\"10\\\", \\\"'20'\\\", \\\"\\\"\\\"30\\\"\\\"\\\", \\\"f00\\\"\\\"b4r\\\"))\")\n @listener.wait_for_table('simplex', 'roles')\n\n assert @cluster.keyspace('simplex').has_table?('roles')\n table_meta = @cluster.keyspace('simplex').table('roles')\n\n assert_equal 'roles', table_meta.name\n assert_equal 'simplex', table_meta.keyspace.name\n assert_empty table_meta.indexes\n refute_nil table_meta.id unless CCM.cassandra_version < '3.0.0'\n refute_nil table_meta.options\n\n assert_columns([['FOO', :text], ['bar', :ascii], ['10', :int], [\"'20'\", :int], [\"\\\"30\\\"\", :int], [\"f00\\\"b4r\", :text]],\n table_meta.primary_key)\n assert_columns([['FOO', :text]], table_meta.partition_key)\n assert_columns([['bar', :ascii], ['10', :int], [\"'20'\", :int], [\"\\\"30\\\"\", :int], [\"f00\\\"b4r\", :text]],\n table_meta.clustering_columns)\n assert_equal :asc, table_meta.clustering_order.first\n\n assert_equal 6, table_meta.columns.size\n table_meta.each_column do |column|\n assert ['FOO', 'bar', '10', \"'20'\", \"\\\"30\\\"\", \"f00\\\"b4r\"].any? { |name| name == column.name }\n assert [:text, :ascii, :int].any? { |type| type == column.type.kind }\n end\n\n table_cql = Regexp.new(/CREATE TABLE simplex\\.\"roles\" \\(\n \"FOO\" text,\n bar ascii,\n \"10\" int,\n \"'20'\" int,\n \"\"\"30\"\"\" int,\n \"f00\"\"b4r\" text,\n PRIMARY KEY \\(\"FOO\", bar, \"10\", \"'20'\", \"\"\"30\"\"\", \"f00\"\"b4r\"\\)\n\\)/)\n\n assert_equal 0, table_meta.to_cql =~ table_cql\n @session.execute(\"DROP TABLE roles\")\n\n # Check all the reserved words\n reserved_word_int_list = [\"zz int PRIMARY KEY\"]\n DatatypeUtils.reserved_words.each do |word|\n reserved_word_int_list.push(\"\\\"#{word}\\\" int\")\n end\n\n @session.execute(\"CREATE TABLE reserved_words (#{reserved_word_int_list.join(',')})\")\n @listener.wait_for_table('simplex', 'reserved_words')\n\n assert @cluster.keyspace('simplex').has_table?('reserved_words')\n table_meta = @cluster.keyspace('simplex').table('reserved_words')\n refute_nil table_meta.to_cql\n @session.execute(\"DROP TABLE reserved_words\")\n end",
"def expire_table_cache(table_names)\n return if @memcache.nil?\n\n table_names.each do |table_name|\n key = \"#{@cache_prefix}-\"+table_name+\"-version\"\n version = @memcache.get(key)\n if version.nil?\n @memcache.set(key,1,nil,{:raw=>true}) \n else\n @memcache.incr(key, 1, nil)\n end\n end\n\n true\n end",
"def check_cache(key)\n checksum = Digest::MD5.hexdigest(key)\n node['data-bag-cache'][node['data-bag-cache']['__checksums__'][checksum]]\n end",
"def test_append_existing\n @cache.add('Key', 'Data1', 0, Time.now.to_i + 60)\n result = @cache.append('Key', '&Data2', 0, Time.now.to_i + 60)\n cache = @cache.get('Key').args\n\n assert_true result.success\n assert_equal 'STORED', result.message.chomp.split(\"\\s\")[0]\n assert_equal 'Data1&Data2', cache.data\n end",
"def cache(data); end",
"def query_cache_store(key)\n raise NotImplementedError\n end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache; end",
"def cache_key\n title.parameterize\n end",
"def get_str_id (str)\n str_id = nil;\n # Trim spaces and truncate if necessary.\n str = str.gsub(/ +/, ' ');\n str = str.sub(/^ /, '');\n str = str.sub(/ $/, '');\n str = str[0..(@max_str_len-1)];\n\n if str == '' then\n return str_id;\n end\n\n # Check cache and return if found.\n if @str_mem.has_key?(str) then\n @str_mem_hit += 1;\n return @str_mem[str];\n end\n @str_mem_miss += 1;\n\n # Else look up in hathi_str.\n @str_exist_q.enumerate(str) do |res|\n str_id = res[:id];\n end\n\n # If not found in hathi_str, insert it.\n if str_id.nil? then\n @bench.time('insert_str') do\n @str_insert_q.execute(str);\n end\n @last_id_q.enumerate do |res|\n str_id = res[:id];\n end\n end\n\n # Make sure cache doesn't grow out of hand.\n if @str_mem.keys.size >= @max_str_mem then\n @bench.time('str_mem') do\n # Mem hash is full, make some room, delete first 10% of keys.\n @str_mem.keys[0 .. (@str_mem.keys.size / 10)].each do |k|\n @str_mem.delete(k);\n end\n end\n end\n\n # Update cache if cache miss.\n @str_mem[str] = str_id.to_i;\n\n return str_id.to_i;\nend",
"def string_include_key?(string, key)\n return false if string.length < key.length\n key.each_char do |ele|\n return true if string.include?(ele)\n end\n\n \nend",
"def cache_on_keys(*key_arr)\n # normalize arguments\n if key_arr.class == Array\n key_arr.flatten!\n key = key_arr.join(\"_\")\n elsif key_arr.class == String || key_arr.class == Symbol\n key = key_arr.to_s\n key_arr = [key_arr]\n else\n raise ArgumentError, \"passed argument(s), must be a string/symbol or an array of strings/symbols\"\n end \n arg_list = key_arr.map{|k| (k.to_s + \"_arg\")} \n tests = []\n key_arr.each_with_index do |val, index|\n tests << \"rec.#{val} == #{arg_list[index]}\"\n end \n \n # build the methods\n class_eval %{\n def self.find_on_#{key}(#{arg_list.join(\", \")})\n @cache_#{key} ||= {}\n @cache_#{key}[ #{ arg_list.collect{|a| a + '.to_s' }.join(\" + '_'+ \")} ] ||= all.select{|rec| #{tests.join(\" && \")}}\n end \n \n # register this cache as something that needs to be deleted when the cache expires\n register_cache('cache_#{key}') \n }\n end",
"def memcached_servers\n %w(127.0.0.1:11211)\n end",
"def test_sdbm\n key = 'あいうえおかきくけこ'\n val = 'たちつてとなにぬねの'\n @tag.tag_db[key] = val\n assert_equal val, @tag.tag_db[key].force_encoding(Encoding::UTF_8)\n end",
"def cache_key\n \"#{protocol}-universe\"\n end",
"def test_backend_does_not_gzip_vary_accept_encoding_shares_cache_when_first_gzip_then_not\n # The cache can be shared in this case, since despite Vary:\n # Accept-Encoding, the response isn't actually gzipped (so no\n # Content-Encoding).\n assert_cacheable(\"/api/cacheable-vary-accept-encoding/\", {\n :accept_encoding => \"gzip\",\n }, {\n :accept_encoding => nil,\n })\n end",
"def test_can_retrieve_keyspace_metadata\n ks_meta = @cluster.keyspace('simplex')\n assert_equal 'simplex', ks_meta.name\n assert_equal 'SimpleStrategy', ks_meta.replication.klass\n assert_equal 1, ks_meta.replication.options['replication_factor'].to_i\n assert ks_meta.durable_writes?\n assert ks_meta.has_table?('users')\n\n results =\n if CCM.cassandra_version < '3.0'\n @session.execute(\"SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = 'simplex'\")\n else\n @session.execute(\"SELECT table_name FROM system_schema.tables WHERE keyspace_name = 'simplex'\")\n end\n assert_equal results.size, ks_meta.tables.size\n\n ks_cql = Regexp.new(/CREATE KEYSPACE simplex WITH replication = {'class': 'SimpleStrategy', \\\n'replication_factor': '1'} AND durable_writes = true;/)\n\n assert_match ks_cql, ks_meta.to_cql\n end",
"def [](string)\n return nil unless cache_on?\n\n @mutex.synchronize { @cache[string] }\n end",
"def test_s33_Serialize_memo_fields\n W('s33a');\n W('s33b');\n W('s33c');\n\n hi = Metakit::Bytes.new(\"hi\", 2);\n gday = Metakit::Bytes.new(\"gday\", 4);\n hello = Metakit::Bytes.new(\"hello\", 5);\n\n p1 = Metakit::BytesProp.new(\"p1\");\n\n Metakit::Storage.open(\"s33a\", 1) {|s1|\n s1.set_structure(\"a[p1:B]\");\n v1 = s1.view(\"a\");\n\n v1.add(p1[hi]);\n v1.add(p1[gday]);\n v1.add(p1[hello]);\n assert_equal hi, p1.get(v1[0])\n assert_equal gday, p1.get(v1[1])\n assert_equal hello, p1.get(v1[2])\n s1.commit();\n assert_equal hi, p1.get(v1[0])\n assert_equal gday, p1.get(v1[1])\n assert_equal hello, p1.get(v1[2])\n\n Metakit::FileStream.open(\"s33b\", \"wb\") {|fs1|\n s1.save_to(fs1);\n }\n\n Metakit::Storage.open(\"s33c\", 1) {|s2|\n Metakit::FileStream.open(\"s33b\", \"rb\") {|fs2|\n s2.load_from(fs2);\n }\n\n v2 = s2.view(\"a\");\n assert_equal hi, p1.get(v2[0])\n assert_equal gday, p1.get(v2[1])\n assert_equal hello, p1.get(v2[2])\n s2.commit();\n assert_equal hi, p1.get(v2[0])\n assert_equal gday, p1.get(v2[1])\n assert_equal hello, p1.get(v2[2])\n s2.commit();\n assert_equal hi, p1.get(v2[0])\n assert_equal gday, p1.get(v2[1])\n assert_equal hello, p1.get(v2[2])\n }\n }\n # D(s33a);\n # D(s33b);\n # D(s33c);\n R('s33a');\n R('s33b');\n R('s33c');\n end",
"def rufus_cabinet_bench (bench_title, db)\n\n db.clear\n\n 2.times { puts }\n puts bench_title\n\n Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|\n\n b.report('inserting one') do\n db['a'] = 'A'\n end\n b.report('inserting N') do\n N.times { |i| db[\"key #{i}\"] = \"value #{i}\" }\n end\n b.report('finding all keys') do\n db.keys\n end\n\n unless db.class.name.match(/^Rufus::Edo::/)\n b.report('finding all keys (native)') do\n db.keys(:native => true).free\n end\n end\n\n b.report('finding all keys (pref)') do\n db.keys(:prefix => 'key ')\n end\n b.report('finding all keys (r pref)') do\n db.keys.select { |k| k[0, 4] == 'key ' }\n end\n b.report('finding all') do\n db.values\n end\n b.report('iterate all') do\n db.each { |k, v| }\n end\n b.report('find first') do\n db[\"key #{0}\"]\n end\n b.report('delete first') do\n db.delete(\"key #{0}\")\n end\n\n txt = 'delete_keys_with_prefix \"1\"'\n txt += ' (M)' if db.class.name == 'Rufus::Edo::Cabinet'\n b.report(txt) do\n db.delete_keys_with_prefix('key 1')\n end\n\n b.report('del keys with prefix \"2\" (m)') do\n ks = db.keys(:prefix => 'key 2')\n ks.each { |k| db.delete(k) }\n end\n end\n\n db.close\nend",
"def [](key)\n puts \"STUB: [] in CacheMethods::Cache\"\n end",
"def key_types; end",
"def key_types; end",
"def sanitize_cache_key(key = \"\")\n key.gsub(/[\\\\\\:\\*\\?\\\"\\<\\>\\|\\s]/,'_')\n end",
"def testit(filename)\n r = Redis.new\n r.config(\"SET\",\"maxmemory\",\"2000000\")\n if $o[:ttl]\n r.config(\"SET\",\"maxmemory-policy\",\"volatile-ttl\")\n else\n r.config(\"SET\",\"maxmemory-policy\",\"allkeys-lru\")\n end\n r.config(\"SET\",\"maxmemory-samples\",5)\n r.config(\"RESETSTAT\")\n r.flushall\n\n html = \"\"\n html << <<EOF\n <html>\n <body>\n <style>\n .box {\n width:5px;\n height:5px;\n float:left;\n margin: 1px;\n }\n\n .old {\n border: 1px black solid;\n }\n\n .new {\n border: 1px green solid;\n }\n\n .otherdb {\n border: 1px red solid;\n }\n\n .ex {\n background-color: #666;\n }\n </style>\n <pre>\nEOF\n\n # Fill the DB up to the first eviction.\n oldsize = r.dbsize\n id = 0\n while true\n id += 1\n begin\n r.set(id,\"foo\")\n rescue\n break\n end\n newsize = r.dbsize\n break if newsize == oldsize # A key was evicted? Stop.\n oldsize = newsize\n end\n\n inserted = r.dbsize\n first_set_max_id = id\n html << \"#{r.dbsize} keys inserted.\\n\"\n\n # Access keys sequentially, so that in theory the first part will be expired\n # and the latter part will not, according to perfect LRU.\n\n if $o[:ttl]\n STDERR.puts \"Set increasing expire value\"\n (1..first_set_max_id).each{|id|\n r.expire(id,1000+id)\n STDERR.print(\".\") if (id % 150) == 0\n }\n else\n STDERR.puts \"Access keys sequentially\"\n (1..first_set_max_id).each{|id|\n r.get(id)\n sleep 0.001\n STDERR.print(\".\") if (id % 150) == 0\n }\n end\n STDERR.puts\n\n # Insert more 50% keys. We expect that the new keys will rarely be expired\n # since their last access time is recent compared to the others.\n #\n # Note that we insert the first 100 keys of the new set into DB1 instead\n # of DB0, so that we can try how cross-DB eviction works.\n half = inserted/2\n html << \"Insert enough keys to evict half the keys we inserted.\\n\"\n add = 0\n\n otherdb_start_idx = id+1\n otherdb_end_idx = id+100\n while true\n add += 1\n id += 1\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n r.set(id,\"foo\")\n r.select(0)\n else\n r.set(id,\"foo\")\n end\n break if r.info['evicted_keys'].to_i >= half\n end\n\n html << \"#{add} additional keys added.\\n\"\n html << \"#{r.dbsize} keys in DB.\\n\"\n\n # Check if evicted keys respect LRU\n # We consider errors from 1 to N progressively more serious as they violate\n # more the access pattern.\n\n errors = 0\n e = 1\n error_per_key = 100000.0/first_set_max_id\n half_set_size = first_set_max_id/2\n maxerr = 0\n (1..(first_set_max_id/2)).each{|id|\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n exists = r.exists(id)\n r.select(0)\n else\n exists = r.exists(id)\n end\n if id < first_set_max_id/2\n thiserr = error_per_key * ((half_set_size-id).to_f/half_set_size)\n maxerr += thiserr\n errors += thiserr if exists\n elsif id >= first_set_max_id/2\n thiserr = error_per_key * ((id-half_set_size).to_f/half_set_size)\n maxerr += thiserr\n errors += thiserr if !exists\n end\n }\n errors = errors*100/maxerr\n\n STDERR.puts \"Test finished with #{errors}% error! Generating HTML on stdout.\"\n\n html << \"#{errors}% error!\\n\"\n html << \"</pre>\"\n $runs << errors\n\n # Generate the graphical representation\n (1..id).each{|id|\n # Mark first set and added items in a different way.\n c = \"box\"\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n c << \" otherdb\"\n elsif id <= first_set_max_id\n c << \" old\"\n else\n c << \" new\"\n end\n\n # Add class if exists\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n exists = r.exists(id)\n r.select(0)\n else\n exists = r.exists(id)\n end\n\n c << \" ex\" if exists\n html << \"<div title=\\\"#{id}\\\" class=\\\"#{c}\\\"></div>\"\n }\n\n # Close HTML page\n\n html << <<EOF\n </body>\n </html>\nEOF\n\n f = File.open(filename,\"w\")\n f.write(html)\n f.close\nend",
"def test_cached\n cached = TestCache.new\n \n # force = false\n assert !cached.cached?(:m1)\n cached.m1\n assert cached.cached?(:m1)\n sleep 4\n assert cached.cached?(:m1)\n \n # force = true\n assert !cached.cached?(:m2)\n cached.m2\n sleep 1\n assert cached.cached?(:m2)\n sleep 3\n assert !cached.cached?(:m2)\n end",
"def mem(key)\n nil == find(key)\n end",
"def cache_key(*ids)\n ids.join(':')\n end",
"def check_cache_validity(client)\n msg = @lookupserver.gets.chomp\n while msg.empty? do\n msg = @lookupserver.gets.chomp\n end\n accessTimeServer = Time.parse(msg)\n compare = accessTimeServer <=> @accessTimeCache\n if (compare <= 0) #Cache copy is valid\n cache_read(client)\n else\n puts @client_msg\n @lookupserver.puts(@client_msg)\n listen_fserver_read(client)\n end\n end",
"def get_kit_cache_key(id)\n fail 'sub class to implement'\n end",
"def prepare\n namespace = @config[:namespace] || 'merb-cache'\n host = @config[:host] || '127.0.0.1:11211'\n @memcache = MemCache.new(host, {:namespace => namespace})\n @tracking_key = \"_#{namespace}_keys\" unless @config[:no_tracking]\n raise NotReady unless @memcache.active?\n true\n rescue NameError\n raise NotDefined\n end",
"def test_supports_key_value_with_timestamp_on_statsite\n @backend.implementation = :statsite\n @backend.expects(:write_packet).with(\"fooy:42|kv|@123456\\n\")\n StatsD.key_value('fooy', 42, 123456)\n end",
"def test_no_block_get\n @noblock_cache.set key, @value\n assert_equal @value, @noblock_cache.get(key)\n end",
"def test_pb_returns_reese\n\t\t(assert_equal(\"reese\", candy_hash(:pb)))\n\tend",
"def test_parse_hash_valid\n assert_equal 100000, parse_hash(\"186A0\")\n end",
"def test_strict_match_criteria\n entry = BigramEntry.new\n entry.parse_line(\"8\t工作\t18904\t6.89133239246\t213454\")\n cedict_entry = CEdictEntry.new\n cedict_entry.parse_line(\"工作 工作 [gong1 zuo4] /job/work/construction/task/CL:個|个[ge4],份[fen4],項|项[xiang4]/\")\n \n result = entry.default_match_criteria.call(cedict_entry,entry)\n assert(true,result)\n end",
"def strlen(key); end",
"def strlen(key); end",
"def get_from_memcache(aml_search_uuid)\n memcache_key_object = self.get_memcache_key_object\n Memcache.get_set_memcached(memcache_key_object.key_template % {\n shard_identifier: self.shard_identifier,\n aml_search_uuid: aml_search_uuid\n },\n memcache_key_object.expiry) do\n self.where(aml_search_uuid: aml_search_uuid).order(:id).all\n end\n end",
"def fetch(key); end",
"def test_cachedel_non_empty_file\n _generic_cachedel_test 4000\n end",
"def test_memory_persistence\n @scrubber.load_extension(Scrubber.extensions[:memory_persistence])\n key = \"My Key\"\n data = \"This is my data\"\n @scrubber.store_record(key, data)\n assert_equal(@scrubber.retrieve_record(key), data, \"Persisted data should match retrieved data\")\n end"
] | [
"0.65002775",
"0.60814196",
"0.5852536",
"0.5838486",
"0.57218456",
"0.5676869",
"0.5647209",
"0.562902",
"0.56267077",
"0.5591895",
"0.5556496",
"0.55473286",
"0.5407236",
"0.5391554",
"0.53385764",
"0.533775",
"0.53327465",
"0.52898294",
"0.52898294",
"0.5282626",
"0.5247381",
"0.5247381",
"0.5247381",
"0.523455",
"0.522911",
"0.522045",
"0.5194081",
"0.5189584",
"0.51827",
"0.51760894",
"0.5175733",
"0.51694006",
"0.51535016",
"0.51519257",
"0.51419926",
"0.513822",
"0.51262456",
"0.51131386",
"0.5110712",
"0.51066685",
"0.5101777",
"0.51005113",
"0.51005113",
"0.5078347",
"0.5075679",
"0.5072818",
"0.50583696",
"0.5055152",
"0.5046669",
"0.50367963",
"0.5029959",
"0.5029959",
"0.50192946",
"0.5011643",
"0.5011596",
"0.5004525",
"0.50030166",
"0.50003505",
"0.49782562",
"0.49721098",
"0.4971792",
"0.4971792",
"0.4971792",
"0.4971792",
"0.4971792",
"0.4971792",
"0.4971792",
"0.4960919",
"0.4951533",
"0.495034",
"0.49490026",
"0.49276754",
"0.4925999",
"0.4919441",
"0.49155846",
"0.49152347",
"0.49031287",
"0.4883905",
"0.48808497",
"0.48729235",
"0.48676154",
"0.48676154",
"0.48652607",
"0.48624557",
"0.48559973",
"0.4855933",
"0.48529416",
"0.48501718",
"0.48434573",
"0.48396426",
"0.48264578",
"0.48134145",
"0.4807737",
"0.48052356",
"0.48001483",
"0.4797664",
"0.4797664",
"0.47955376",
"0.47925645",
"0.47909194",
"0.47867903"
] | 0.0 | -1 |
note : pre db.clear and post db.close are included. | def rufus_table_bench (bench_title, db)
2.times { puts }
puts bench_title
Benchmark.benchmark(' ' * 31 + Benchmark::Tms::CAPTION, 31) do |b|
db.clear
db.clear
db.set_index('name', :lexical)
b.report('inserting data (index set)') do
DATA1.each_with_index { |e, i| db["key #{i.to_s}"] = e }
end
db.clear
db.set_index('name', :remove)
b.report('inserting data (no index)') do
DATA1.each_with_index { |e, i| db["key #{i.to_s}"] = e }
end
b.report('finding all keys') do
db.keys
end
b.report('finding all keys (pref)') do
db.keys(:prefix => 'key ')
end
b.report('finding all keys (r pref)') do
db.keys.select { |k| k[0, 4] == 'key ' }
end
b.report('finding all') do
db.query { |q| }
end
b.report('find last') do
db["key #{DATA.size.to_s}"]
end
b.report('delete last') do
db.delete("key #{DATA.size.to_s}")
end
b.report('find Alphonse') do
db.query { |q| q.add('name', :equals, DATA1[0]['name']) }
end
b.report("setting index (#{DATA.size} rows)") do
db.set_index('name', :lexical)
end
b.report('find Alphonse (index set)') do
db.query { |q| q.add('name', :equals, DATA1[0]['name']) }
end
b.report('delete_keys_with_prefix "1"') do
db.delete_keys_with_prefix('key 1')
end
#b.report('del keys with prefix "2" (m)') do
# ks = db.keys(:prefix => 'key 2')
# ks.each { |k| db.delete(k) }
#end
end
db.close
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flushdb; end",
"def close()\n @db.close()\n end",
"def close\n db.close\n end",
"def teardown\n @db.close\n super\n end",
"def close\n @db.close\n end",
"def flushdb\n end",
"def close_database\n @database = nil\n @writable_database = nil\n GC.start\n end",
"def close_database\n @database = nil\n @writable_database = nil\n GC.start\n end",
"def close\n @dbman.close\n @dbprot.clear\n end",
"def close\n\n @db.connection.close\n end",
"def close\n @db.close if @db && !(@db.closed?)\n self\n end",
"def close\n @database.close if @database\n end",
"def close\n @database.close if @database\n end",
"def close_connection\n @db.close if @db\n end",
"def db_close\n @dbh and @dbh.close\n @dbh = nil\n end",
"def db_close\n @dbh and @dbh.close\n @dbh = nil\n end",
"def clear\n @db.clear\n self\n end",
"def clear_db\n @@db.clear_db\n end",
"def shutdown\n\n @db.connection.close\n end",
"def close\n lib.tcidbclose( @db ) || raise_error\n\n lib.tcidbdel( @db )\n\n @db = nil\n end",
"def database_reset\n @database = nil\n end",
"def final\n @DB.close\n # Remove eventually temporary file\n if (@TmpFileName != nil)\n File.unlink(@TmpFileName)\n end\n end",
"def db_remove!( db_file )\n ####db = SQLite3::Database.new( db_file )\n ####db.execute( db_remove )\n ####db.close \n puts \"SQLite3\"\n end",
"def reset_db\n \n end",
"def clear_db\n clear_urls + clear_docs\n end",
"def clear\n run_hook(:before_clear)\n db.clear\n run_hook(:after_clear)\n end",
"def flush_db\n [ 'active_sources', 'data_records', 'semantic_properties', 'semantic_relations', 'workflows'].reverse.each { |f| ActiveRecord::Base.connection.execute \"DELETE FROM #{f}\" }\n # Also remove the \"unsaved cache\" for the wrappers (may be important during testing)\n TaliaCore::SemanticCollectionWrapper.instance_variable_set(:'@unsaved_source_cache', {})\n end",
"def clear_db\n\t\tdb = SQLite3::Database.open \"simpl.db\"\n\t\tdb.execute \"DELETE FROM user;\"\n\t\tdb.execute \"DELETE FROM merchant;\"\n\t\tdb.execute \"DELETE FROM transactions;\"\n\tend",
"def clear_db\n\t\tdb = SQLite3::Database.open \"simpl.db\"\n\t\tdb.execute \"DELETE FROM user;\"\n\t\tdb.execute \"DELETE FROM merchant;\"\n\t\tdb.execute \"DELETE FROM transactions;\"\n\tend",
"def flushdb\n redis.flushdb\n end",
"def reinitialize_db\n drop_db\n initialize_db\n end",
"def clear_db()\n ScraperWiki.sqliteexecute('DELETE FROM event')\nend",
"def clear_db()\n ScraperWiki.sqliteexecute('DELETE FROM event')\nend",
"def close\n SQLite::API.close( @handle )\n @closed = true\n end",
"def close\n @mysql.close\n @mysql = nil\n end",
"def flushdb\n\t\t\[email protected]\n\t\t\[email protected](\"Flushing database\")\n\t\tend",
"def close\n commit\n end",
"def flush_database\n\t\t\tp \"Flushing Database\"\n\t\t\tAdmin.destroy_all\n\t\t\tCountry.destroy_all\n\t\t\tDoorkeeper::Application.destroy_all\n\t\tend",
"def flushdb\n @redis.flushdb\n end",
"def closeDBConn()\n if ( !@db_conn.nil? )\n begin\n @db_conn.finish()\n rescue Exception => e\n #ignore it\n end\n end\n end",
"def flushdb\n on_each_node :flushdb\n end",
"def clear!(db_as_well=true)\n Document.destroy_all if db_as_well\n close\n Dir.glob(File.join(Picolena::IndexSavePath,'**/*')).each{|f| FileUtils.rm(f) if File.file?(f)}\n end",
"def flushdb(options = T.unsafe(nil)); end",
"def teardown\n teardown_db\n end",
"def close\n # by default do nothing - close any cached connections\n end",
"def close\n #active record should do our connections for us so just set to nil\n @connection = nil\n # Remove this connection from the list of open connections.\n #@@open_connection = @@open_connections.reject { |c| c[:db_url] == @db_url }\n Log.instance.debug \"Disconnected from #@db_url\"\n end",
"def disconnect_and_quit\n $db.close\n puts \"Closing DB. Bye!\"\n exit\nend",
"def hard_clean!\n open_db\n @file.truncate(PREAMBLE_SIZE)\n write_fresh_database\n end",
"def close\n @tc_bdb.close\n @tc_bdbcur = nil\n end",
"def close\n #Ruote::ActiveRecord::Document.before_fork\n end",
"def commit\n # Nothing to do for an in memory database\n end",
"def clear\n\t\t@data_base = {}\n\t\tupdate_database\n\tend",
"def clear\n lib.tcidbvanish( @db )\n end",
"def close\n #import\n @insert_point.close if !@insert_point.nil?\n @check_md5.close if !@check_md5.nil?\n @insert_md5.close if !@insert_md5.nil?\n #export\n @export_point_page.close if !@export_point_page.nil?\n @export_point_all.close if !@export_point_all.nil?\n @db.close\n end",
"def clean\n\t\t\n\t\[email protected] 'twitter'\n\t\[email protected] 'rpg'\n\t\n\tend",
"def shutdown(this_db = @db)\n this_db.shutdown if this_db\n end",
"def shutdown(this_db = @db)\n this_db.shutdown if this_db\n end",
"def commit_db_transaction() end",
"def commit_db_transaction() end",
"def teardown\n\t\tActiveRecord::Base.clear_all_connections!\n\t\t#File.delete \"test.sqlite\"\n\tend",
"def close(save=true)\n raise InvalidDbError if @stale\n\n if save && staging?\n self.staging.write\n end\n unstage\n @stale = true\n\n # TODO: remove all locks etc\n end",
"def release\n chk_conn\n @connected = false\n @db.release(self)\n end",
"def close_db_connection\n if ActiveRecord::Base.connection\n ActiveRecord::Base.connection.close\n end\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each(&:delete_all)\n end",
"def quit\n @watch.quit # <-- should close all the files\n # and that should allow the sincedb_write to succeed if it could not before\n _sincedb_write\n end",
"def endRun\n db_cached_connect\n\n @dbh.do(\"SELECT endRun();\")\n @dbh.do(\"COMMIT TRANSACTION;\")\n end",
"def close\n IBM_DB.close(@conn)\n end",
"def clear\n instrument(:clear, nil, nil) do\n failsafe(:clear) do\n with(&:flushdb)\n end\n end\n end",
"def db_clear\n [Project, Milestone, Category, Version, LoaderRelease].each {|x| x.delete_all}\n end",
"def close()\n #This is a stub, used for indexing\n end",
"def disconnect\n database.close if connected?\n @@connections[name][db_name] = nil\n end",
"def close() end",
"def close() end",
"def close() end",
"def close() end",
"def close() end",
"def clean_up()\n puts \"Closing MQTT and DB connections\"\n closeMQTTConn()\n closeDBConn()\n end",
"def flushall; end",
"def db; end",
"def db; end",
"def close\n persist\n end",
"def shutdown\n drop_database\n end",
"def flushdb\n with_failover { redis.flushdb }\n end",
"def commit\n @db.commit\n end",
"def clean_db\n Mongoid::Sessions.default.collections.select {|c| c.name !~ /system/}.each {|c| c.find.remove_all}\n end",
"def destroy_file\n db_file.destroy if db_file\n end",
"def closed?\n @db.closed?\n end",
"def drop_db\n Mongoid.purge!\n end",
"def clean_database\n\t\t\t\tbegin\n\t\t\t\t\tupdate_all(XSSF_VICTIM_DB, XSSF_VICTIM_HASH, {\"CURRENT_ATTACK_URL\" => nil, \"TUNNELED\" => false})\n\t\t\t\t\tdelete_all(XSSF_WAITING_ATTACKS_DB) \n\t\t\t\trescue\n\t\t\t\t\tprint_error(\"Error 10: #{$!}\") if (XSSF_MODE[0] =~ /^Debug$/i)\n\t\t\t\tend\n\t\t\tend",
"def finalize\n @request_count = @orm_module::Request.count\n ActiveRecord::Base.remove_connection\n end",
"def clear\n @redis.flushdb\n end",
"def delete_all\n begin\n db.execute \"TRUNCATE TABLE #{table}\"\n\n rescue SQLite3::Exception => e\n puts \"Database Exception occured\"\n puts e\n \n ensure\n db.close if db\n end\n end",
"def remove_database\n FileUtils.rm_rf(path) if File.exist? File.join(path, \"iamflint\")\n @database = nil\n @writable_database = nil\n end",
"def clean_db\n\n puts \"Caching wikipedia links\"\n @wikipedia_cache = {}\n Artist.all\n .where('wikilink IS NOT NULL')\n .pluck( 'name' , 'wikilink' )\n .each { |result| @wikipedia_cache[ key_name(result[0]) ] = result[1] }\n\n puts \"Cleaning db\"\n PlayerState.delete_all\n PlayListSong.delete_all\n Song.delete_all\n Album.delete_all\n Artist.delete_all\n end",
"def delete\n open\n returning db.delete(self.key) do |result|\n close\n end\n end",
"def database\n db = SQLite3::Database.new 'foosey.db'\n\n yield db\nrescue SQLite3::Exception => e\n puts e\n puts e.backtrace\nensure\n db.close if db\nend",
"def teardown\n self.db_disconnect\n self.logout()\n super\n end",
"def remove_database\n FileUtils.rm_rf(path) if File.exist? File.join(path, \"record.DB\")\n @database = nil\n @writable_database = nil\n end",
"def finalize\n close\n end",
"def close; end",
"def close; end"
] | [
"0.8017672",
"0.8003482",
"0.7964477",
"0.79576695",
"0.79547226",
"0.7762445",
"0.7713137",
"0.7713137",
"0.7583649",
"0.75371397",
"0.7520301",
"0.7483301",
"0.7483301",
"0.7478101",
"0.7447181",
"0.7447181",
"0.73035866",
"0.7292043",
"0.72798586",
"0.7228022",
"0.72170347",
"0.7136655",
"0.7128141",
"0.7113956",
"0.71042633",
"0.7092784",
"0.70518374",
"0.7022632",
"0.7022632",
"0.69522274",
"0.69382155",
"0.69353956",
"0.69353956",
"0.6917382",
"0.68811685",
"0.68647426",
"0.6852132",
"0.68006086",
"0.6784505",
"0.678072",
"0.67474633",
"0.6745204",
"0.67401606",
"0.67043316",
"0.66835785",
"0.6673256",
"0.66372234",
"0.66338646",
"0.66195095",
"0.66101265",
"0.65920115",
"0.6587246",
"0.65794224",
"0.6549525",
"0.65359443",
"0.6534179",
"0.6534179",
"0.6503555",
"0.6503555",
"0.6499175",
"0.6476221",
"0.6472381",
"0.647101",
"0.64653206",
"0.6446562",
"0.64450884",
"0.6439604",
"0.6428165",
"0.64228743",
"0.6415833",
"0.63546926",
"0.6350693",
"0.6350693",
"0.6350693",
"0.6350693",
"0.6350632",
"0.6316285",
"0.63142294",
"0.6313086",
"0.6313086",
"0.6307381",
"0.6276783",
"0.6263571",
"0.6255561",
"0.6251497",
"0.6248566",
"0.6237844",
"0.6233786",
"0.62291414",
"0.62266505",
"0.62226456",
"0.6218964",
"0.62154114",
"0.61947656",
"0.61917555",
"0.6190093",
"0.6188564",
"0.6176121",
"0.6168089",
"0.6157343",
"0.6157343"
] | 0.0 | -1 |
Get all of the parts for a given type TODO Have this return an enumerable of parts so we can fitler by parttype. We can filter this by type from whatever is calling it if we blow open some new types... | def parts(type)
xml.xpath("//xmlns:Override[@ContentType='#{type}']").map{ |n| n['PartName'] }
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parts(user_id = nil)\n part_elements = []\n if is_a_node?\n if user_id\n part_elements = Element.part_elements_for_element_id_by_user_id(self.id, user_id)\n else\n part_elements = Element.part_elements_for_element_id(self.id)\n end\n end\n return part_elements\n end",
"def parts\n @parts\n end",
"def parts\n @doc.content_types.parts Slide::CONTENT_TYPE\n end",
"def email_parts_of_type(email, content_type = \"text/plain\")\n email.body.parts.select {|part|\n if part.respond_to?(:content_type)\n part.content_type.downcase.include? content_type\n end\n }\n end",
"def parts_query\n ActiveRDF::Query.new(TaliaCore::ActiveSource).select(:part).where(:part, N::DCT.isPartOf, self)\n end",
"def parts\n product.parts\n end",
"def parts\n product.parts\n end",
"def list_parts(options = {})\n result = client.bucket_list_parts(upload_id, key, options)\n .parsed_response\n\n parts_keys = %w(ListPartsResult Part)\n Utils.wrap(Utils.dig_value(result, *parts_keys)).map do |part|\n Struct::Part.new(part)\n end\n end",
"def parts; end",
"def parts; end",
"def parts; end",
"def parts\n @body.xpath('./a:part', a: NS)\n end",
"def components_with_type(type)\n array = []\n @components.each_value do |c|\n array << c.proxy.name if c.proxy.respond_to?(:has_type?) &&\n c.proxy.has_type?(type)\n end\n array\n end",
"def list_parts\n # if @@parts == nil\n # @@parts = ZAutoParts::Deal.today\n # #this is a little trick by putting the (1) we don't have to put -1, it starts the index at 1.\n # # @@parts.each.with_index(1) do |part, i|\n # # puts \"#{i}. #{part.name.colorize(:blue)} - #{part.price}\"\n # tp @@parts, :number, {:name => {:width => 50}}, :price\n # # binding.pry\n # # end\n # else\n tp self.parts, :number, {:name => {:width => 50}}, :price\n # @@parts.each.with_index(1) do |part, i|\n # puts \"#{i}. #{part.name.colorize(:blue)} - #{part.price}\"\n # end\n # end\n end",
"def contents_by_type(essence_type)\n contents.select do |content|\n content.essence_type == Content.normalize_essence_type(essence_type)\n end\n end",
"def get_piece_list(type, color)\n piece_list = []\n @infosquare.each do |row|\n row.each do |item|\n if item.type_piece == type and item.color_piece == color\n piece_list << item\n end\n end\n end\n return piece_list\n end",
"def get_piece_list(type, color)\r\n piece_list = []\r\n @infosquare.each do |row|\r\n row.each do |item|\r\n if item.type_piece == type and item.color_piece == color\r\n piece_list << item\r\n end\r\n end\r\n end\r\n return piece_list\r\n end",
"def fields_of_type(type, &block)\n selected = @fields.select {|f| type == f.type }\n if block\n selected.each {|f| f.instance_eval &block }\n end\n selected\n end",
"def mime_types\n [].tap do |result|\n @parts.each do |part|\n result << part.content_type\n end\n end\n end",
"def list_partitions_with_size_and_type # by nelsongs. => list: partition size type\n\treturn `fdisk -l | grep /dev | grep -v Disk | awk '{if ($2==\"*\") print $1\":\"$5\":\"$6;else print $1\":\"$4\":\"$5}' | sed s/+//g`.split\nend",
"def mime_parts(uids, mime_type)\n media_type, subtype = mime_type.upcase.split('/', 2)\n\n structures = imap.fetch uids, 'BODYSTRUCTURE'\n\n structures.zip(uids).map do |body, uid|\n section = nil\n structure = body.attr['BODYSTRUCTURE']\n\n case structure\n when Net::IMAP::BodyTypeMultipart then\n parts = structure.parts\n\n section = parts.each_with_index do |part, index|\n break index if part.media_type == media_type and\n part.subtype == subtype\n end\n\n next unless Integer === section\n when Net::IMAP::BodyTypeText, Net::IMAP::BodyTypeBasic then\n section = 'TEXT' if structure.media_type == media_type and\n structure.subtype == subtype\n end\n\n [uid, section]\n end.compact\n end",
"def each(&block)\n return @parts.each(&block)\n end",
"def children_by_type(type)\n children = YARD::Registry.all(type)\n children.select { |child| child.parent == self }\n end",
"def parts\n body.parts\n end",
"def random_parts_1\n parts = []\n (1..8).each do |id|\n parts.push(Part.new(part_type_id: id, defect: ([false]*19 << true).sample))\n end\n parts\n end",
"def index\n @image_to_parts = ImageToPart.all\n end",
"def get_data_elements_by_type(patient, type)\n matches = []\n patient.dataElements.each do |data_element|\n matches << data_element if data_element[:_type] == type\n end\n matches\n end",
"def parts_from_sample(collection, sample)\n part_location = collection.find(sample)\n parts = []\n part_location.each do |coordinates|\n parts.push(collection.part(coordinates[0], coordinates[1]))\n end\n parts\n end",
"def find_mail_part(mail, types)\n types.each do |type|\n part = mail.parts.find { |p| p.content_type.start_with? type }\n return part unless part.nil?\n end\n # No part found.\n nil\n end",
"def index\n @parts = @chaper.parts\n end",
"def products_by_type(type)\n all_products.select { |product| filter_item_by_type(product, TARGET_PRODUCT_FIELD, type) }\nend",
"def items_for_type(type)\n all_ids = []\n valid_ids = []\n AllItems.get.each do |item_code, values|\n _item_name, item_type, item_valid = values\n next unless item_type == type\n all_ids << item_code\n valid_ids << item_code if item_valid\n end\n\n [all_ids, valid_ids]\n end",
"def partition_by_type(names)\n return names.partition { |n| n[:val] =~ /[A-Z][a-z]+/}\n end",
"def get_by_type(type)\r\n facts2typerule = {:methodcall => [:cant_access, :can_access],\r\n :inheritance => [:cant_extend, :can_extend],\r\n :objcreation => [:cant_create, :can_create]}\r\n\r\n find_all { |x| facts2typerule[type].index(x.type_interaction) != nil }\r\n end",
"def elements_by_type(type)\n\t\treturn xpath('//' + type)\n\tend",
"def each &block\n @parts.each(&block)\n end",
"def parts( format )\n @parts[format.to_s] ||= file ? @storage.find_page_parts( file, @lang, format.to_s ) : {}\n end",
"def extract_types(doc)\n types = []\n @raw_types.each do |raw_type|\n doc.each_element_with_attribute('name', raw_type, 0,\n '//schema/complexType') do |type_node|\n type = {:name => raw_type, :fields => []}\n ext_node = REXML::XPath.first(type_node, 'complexContent/extension')\n if ext_node\n base_type = ext_node.attribute('base').to_s.gsub(/^.+:/, '')\n type[:base] = base_type\n @raw_types << base_type unless @raw_types.include?(base_type)\n seq_node = REXML::XPath.first(ext_node, 'sequence')\n fields = get_element_fields(seq_node)\n process_method_field_types(fields)\n type[:fields] += fields\n end\n seq_node = REXML::XPath.first(type_node, 'sequence')\n if seq_node\n fields = get_element_fields(seq_node)\n process_method_field_types(fields)\n type[:fields] += fields\n end\n types << type\n end\n end\n return types\n end",
"def section_types\n type.children.select { |child| child.class == SectionType }\n end",
"def return_sub_types\n main_type = type_status\n if main_type\n return self.beer_subtypes.map{|type| {id: type.id, name: type.name}}\n else\n return types_for_subtype\n end\n end",
"def decode_mime_parts part, preferred_type, level=0\n if part.multipart?\n if mime_type_for(part) =~ /multipart\\/alternative/\n target = part.body.find { |p| mime_type_for(p).index(preferred_type) } || part.body.first\n if target # this can be nil\n decode_mime_parts target, preferred_type, level + 1\n else\n []\n end\n else # decode 'em all\n part.body.compact.map { |subpart| decode_mime_parts subpart, preferred_type, level + 1 }.flatten 1\n end\n else\n type = mime_type_for part\n filename = mime_filename_for part\n id = mime_id_for part\n content = mime_content_for part, preferred_type\n [[type, filename, id, content]]\n end\n end",
"def index\n @user = current_user\n if params[ :search ] && (params[ :search ].length > 0) then\n @parts = search( Part, params[ :search ], ['own_id', 'third_id', 'desc'] )\n @part_insts = nil\n @parts.each do |part|\n pis = PartInst.where( part_id: part.id )\n if ( @part_insts ) then\n @part_insts = @part_insts + pis\n else\n @part_insts = pis\n end\n end\n @paginate = false\n else\n @part_insts = PartInst.paginate( page: params[ :page ], per_page: 10 )\n @paginate = true\n end\n @boxes = Box.all\n end",
"def partition_types_ext\n ptr1 = MemoryPointer::new( :size_t, 1)\n error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPES_EXT, 0, nil, ptr1)\n error_check(error)\n ptr2 = MemoryPointer::new( ptr1.read_size_t )\n error = OpenCL.clGetDeviceInfo(self, PARTITION_TYPES_EXT, ptr1.read_size_t, ptr2, nil)\n error_check(error)\n arr = ptr2.get_array_of_cl_device_partition_property_ext(0, ptr1.read_size_t/ OpenCL.find_type(:cl_device_partition_property_ext).size)\n arr.reject! { |e| e == 0 }\n return arr.collect { |e| PartitionEXT::new(e.to_i) }\n end",
"def decode_mime_parts part, preferred_type, level=0\n if part.multipart?\n if mime_type_for(part) =~ /multipart\\/alternative/\n target = part.body.parts.find { |p| mime_type_for(p).index(preferred_type) } || part.body.parts.first\n if target # this can be nil\n decode_mime_parts target, preferred_type, level + 1\n else\n []\n end\n else # decode 'em all\n part.body.parts.compact.map { |subpart| decode_mime_parts subpart, preferred_type, level + 1 }.flatten 1\n end\n else\n type = mime_type_for part\n filename = mime_filename_for part\n id = mime_id_for part\n content = mime_content_for part, preferred_type\n [[type, filename, id, content]]\n end\n end",
"def random_parts_2\n parts = []\n parts.push(Part.new(part_type_id: 9, defect: ([false]*9 << true).sample))\n parts\n end",
"def patterns_for_type(type_)\n @mutex.synchronize do\n typedata_ = @types[type_]\n typedata_ ? typedata_.dup : []\n end\n end",
"def all_page_part_content\n parts.map(&:body).join \" \"\n end",
"def __endpoint_parts\n parts = @spec['url']['paths'].select do |a|\n a.keys.include?('parts')\n end.map do |path|\n path&.[]('parts')\n end\n (parts.inject(&:merge) || [])\n end",
"def body_parts\n\t @part.getCount.times.map do |index|\n\t\tpart = @part.getBodyPart(index)\n\t\tnext(BodyPart.new(part, self)) \\\n\t\t unless @message.is_a?(javax.mail.Multipart)\n\t\tMultipart.new(part, self)\n\t end\n\tend",
"def sort_parts!\n @parts.each do |p|\n p.body.set_sort_order(@part_sort_order)\n p.body.sort_parts!\n end\n @parts.sort!(@part_sort_order)\n end",
"def get_part\n @part\n end",
"def get_records_of_type requested_record_type\n ui2 = @records_unpacked\n records = []\n\n ui2_size = ui2.size\n offset = 0\n ptr = ui2\n record_byte_offset = 0\n record_type_array = Array(requested_record_type)\n\n while(offset < ui2_size) do\n curr_record_type = ptr[offset]\n record_size = ptr[offset+1]\n\n offset += (record_size/2)\n\n #yield records, curr_record_type, offset, ptr\n #do |records, record_type, offset, ptr|\n if record_type_array.include? curr_record_type\n #records.push(ptr[record_byte_offset...record_byte_offset+record_size].pack('S>*'))\n records.push(@records_packed[record_byte_offset...record_byte_offset+record_size])\n end\n #end\n\n record_byte_offset += record_size\n #ptr = ptr[(record_size/2)..-1]\n end\n\n records\n end",
"def get_available_multipart_form_parts(form_name, last_completed_part)\n add_parts = true\n parts = []\n # loop over the parts\n self.multipart_forms[form_name][:parts].each do |part|\n if( add_parts && !part.match(/_update$/) )\n parts << { :name => part, :number => parts.length + 1 }\n end\n if !ActsAsMultipartForm.config.show_incomplete_parts && part.to_s == last_completed_part.to_s\n add_parts = false \n end\n end\n return parts\n end",
"def each(&proc)\n @parts.each(&proc)\n end",
"def scan_parts(message)\n message.parts.each do |part|\n if part.multipart?\n scan_parts(part)\n else\n case part.content_type\n when /text\\/plain/\n @body << part.body.to_s\n when /text\\/html/\n @html << part.body.to_s\n else\n att = Attachment.new(part)\n @attachments << att if att.attached?\n end\n end\n end\n end",
"def get_part_by_company_part\n @parts = PartsController::PartService.get_part_by_company_part(params[:param_part])\n if [email protected]?\n respond_to do |format|\n format.json{ render json: @parts}\n end \n else\n #não foi encontrado as informacoes\n end\n\tend",
"def parts\n @audio_file = AudioFile.find(params[:id])\n @parts = @audio_file.parts\n\n respond_to do |format|\n format.html # parts.html.erb\n format.xml { render :xml => @parts }\n format.json { render :json => @parts }\n end\n end",
"def index\n @part_attributes = PartAttribute.all\n end",
"def index\n @parts = Part.search(params[:search]).paginate(:page => params[:page], :per_page => 30)\n end",
"def index\n @parts = Part.preload(:job)\n end",
"def find_part( format, part_name, inherit = false )\n page = self\n part = self.parts(format)[part_name]\n\n while inherit && !part && page.parent do\n page = page.parent\n part = page.parts(format)[part_name]\n end\n\n part\n end",
"def externals(type)\n @externals ||= []\n\n type = type.to_sym\n parent_externals = if superclass.respond_to?(:externals)\n superclass.externals(type)\n else\n []\n end\n\n my_externals = @externals.select do |external|\n external.type == type\n end\n\n (parent_externals + my_externals).uniq\n end",
"def groups_by_asset_type(type)\n arr = []\n groups.each do |group|\n arr << group if !@bundles[group.to_s].assets(type.to_sym).empty?\n end\n return arr\n end",
"def get_all_sobjects(type)\n case type\n when 'Account'\n records = @client.materialize(type).query(\"Agents__c != ''\")\n when 'ccrmbasic__Email__c'\n records = @client.materialize(type).query(\"ccrmbasic__Contact__c != ''\")\n else\n records = @client.materialize(type).all\n end\n sobjects = records.dup.to_a\n while records.next_page?\n sobjects += records.next_page\n records = records.next_page\n end\n sobjects\n end",
"def proper_types\n Page.distinct(:_type).reject { |type| type.constantize.new.entry? }\n end",
"def joined_by_type(type)\n\t\tArray(self.joined.find_all_by_joinable_type(type))\n\tend",
"def make_parts(iterator, internal_sorter)\n slice = START_SLICE_SIZE\n\n parts = []\n part = []\n\n loop do\n begin\n # Enumerator does not have slice method\n slice.times { part << iterator.next }\n rescue StopIteration\n break\n end\n\n # Carefully memory_limit is variable\n if memory_usage > memory_limit\n # Sort current part with origin key_function\n internal_sorter.sort(part)\n # Tempfile for current part\n # will be destroyed on #destroy_temp_folder\n file = Tempfile.new(\"part\", @dir)\n serializer.dump(part, file)\n # Peek is at the end of file\n file.seek(0)\n parts << serializer.load(file)\n\n # Some memory will be released but not immediately\n # need some new memory for start\n part.clear\n add_memory!\n else\n slice = [slice*2, MAX_SLICE_SIZE].min\n end\n end\n\n # Last part which is not in the file\n if part.any?\n internal_sorter.sort(part)\n parts << part.each\n end\n\n parts\n end",
"def part(mime_type)\n part = mail.parts.find{|p| p.mime_type == mime_type}\n part.body.to_s if part\n end",
"def all_page_part_content\n\t content = \"\"\n\t \n\t self.parts.each do |part|\n\t content << \" #{part.body}\"\n\t end\n\t \n\t content\n\tend",
"def address_components_of_type(type)\n address_components.select{ |c| c['types'].include?(type.to_s) }\n end",
"def interested_parties\n \t@interested_parties = []\n\t @interested_parties << self.watchings.all\n\t @interested_parties << self.path.interested_parties\n\t @interested_parties.flatten.compact\n\tend",
"def type_specific_part_raw\n return @type_specific_part_raw unless @type_specific_part_raw.nil?\n @type_specific_part_raw = type_specific_part_raw_with_io.data\n @type_specific_part_raw\n end",
"def parts(url, path_based_params=false)\n return {} unless url\n\n # Parse out the URL parts\n parts = parse_url url\n\n return {} if not parts\n\n params = {}\n # Parse out the param-based parts\n if parts['query']\n pairs = parts['query'].split '&'\n pairs.each do |pair|\n key,value = pair.split '='\n value = CGI::unescape value.to_s\n params[key] = value\n end\n end\n # Parse bath-based URL params\n if path_based_params\n if parts['path']\n pairs = parts['path'].split '/'\n pairs.each do |pair|\n if pair.include? '='\n key,value = pair.split '='\n value = CGI::unescape value\n params[key] = value\n end\n end\n end\n end\n parts['params'] = params\n\n return parts\n end",
"def free_tems_with_sec(sec_type)\n tems = []\n @free_tems.each do |index_tem, true_value|\n tems << index_tem.last if @with[sec_type].include? index_tem.last\n end\n tems\n end",
"def proper_pages\n Page.where(:_type.in => proper_types)\n end",
"def index\n @part_details = PartDetail.all\n end",
"def get_part_by_category\n @categorys = PartsController::PartService.get_part_by_category(params[:param]);\n respond_to do |format|\n format.json { render json: @categorys }\n end \n end",
"def parse_parts(code = nil)\n code ||= self.code\n # parse the given code\n t = Liquid::Template.parse(code)\n keys = []\n # add the several markers to keys = []\n t.root.nodelist.each { |part| keys << part.name if part.is_a? Liquid::Variable }\n # remove allocated tags\n keys.delete_if { |e| ALLOCATED_TAGS.include?(e) }\n # remove duplicates\n keys.uniq\n # remove not existing parts\n current_keys = TemplatePart.find_all_by_template_id(self.id).collect { |t| t.key }\n not_existing_parts = current_keys - keys\n not_existing_parts.each { |part| TemplatePart.find_by_template_id_and_key(self.id, part).destroy }\n # create new markers\n keys.each { |key| self.template_parts.find_or_create_by_key(key) }\n end",
"def get_parts(poly)\n\tif poly.kind_of? Array\n mypoly = poly.compact\n\t [mypoly, mypoly[-1]]\n else\n [poly, poly]\n end\n end",
"def get_part(args)\n return send(args[:page]).send(args[:part][:locate])[args[:part][:num]] if part_plural?(args)\n\n send(args[:page]).send(args[:part])\n end",
"def index\n @subparts = Subpart.all\n end",
"def pieces\n list = []\n n = @data['info']['pieces'].bytesize / PIECE_SIZE\n n.times do |i|\n list << @data['info']['pieces'][(i * PIECE_SIZE)..(i * PIECE_SIZE + PIECE_SIZE - 1)]\n end\n list\n end",
"def partition(&block) # :nodoc:\n resolve\n result = @items.partition(&block)\n [\n PropertyGroup::PathList.new.import(result[0]),\n PropertyGroup::PathList.new.import(result[1]),\n ]\n end",
"def part_title_by_type(resource_type)\n if self.type == resource_type\n self.title\n elsif self.has_part && self.has_part.type == resource_type\n self.has_part.title\n else\n nil\n end\n end",
"def index\n @order_parts = OrderPart.all\n end",
"def parts\n @parts ||= begin\n ary = string.split(/said/i, 2)\n if ary.size == 2 && ary[0].size > 31\n [string]\n else\n ary\n end\n end\n end",
"def each\n\t parts = body_parts.map { |p| \n\t\tp.multipart? ? p.body_parts : p }\n\t parts.flatten.compact.each { |p| yield(p) }\n\tend",
"def custom_fields_by_type(type)\n custom_fields.select { |field| field.type == \"platformCore:#{type}\" }\n end",
"def getObjects(iTypeName)\n return getType(iTypeName).getObjects\n end",
"def fields_for_type(type)\n return @field_mapping[type] || Set.new\n end",
"def by_type\n return @by_type if @by_type\n\n @by_type = {}\n self.all.each do |set|\n next unless set[:types].count > 0\n\n set[:types].each do |t|\n @by_type[t] ||= []\n @by_type[t] << set\n end\n end\n\n @by_type\n end",
"def concat parts\n self.parts.concat parts\n end",
"def fetch_contrib_programmes_for(entity, type, availability_type=:episode)\n programmes = []\n pids = []\n contrib_pid = fetch_contributor_pid_for(entity.url_key)\n return nil unless contrib_pid.present?\n params = {\n people: contrib_pid,\n availability_entity_type: availability_type,\n availability: 'available',\n media_set: 'pc',\n mixin: 'titles'\n }\n params['media_type'] = type == :radio ? 'audio' : 'audio_video' ;\n url = remove_brackets api_endpoint_for('programmes', params)\n response = get(url)\n return nil unless response.code == 200\n begin\n xml_doc = Nokogiri::XML(response.body)\n if availability_type == 'clip'\n # debugger\n end\n pids = extract_pids(xml_doc)\n rescue\n nil\n end\n\n pids.each do |pid|\n programmes << ::Programmes.fetch_programme(pid)\n end\n programmes.compact\n end",
"def part(params = {})\n new_part = Part.new(params)\n yield new_part if block_given?\n add_part(new_part)\n end",
"def find_type_elements(type, nested = T.unsafe(nil), elements = T.unsafe(nil)); end",
"def index\n @type_partners = TypePartner.all\n end",
"def get_models(model_type)\n model_store.get_collection class_for_type(model_type)\n end",
"def split_on(parts)\n\n raise ArgumentError.new(\"Parts should be Integer greater than 0.\") unless parts.is_a? Integer and parts > 0\n raise ArgumentError.new(\"Subnet has #{size} elements only.\") if parts > size\n\n if size % parts == 0\n part_size = size / parts\n else\n part_size = size / (parts - 1)\n if size % part_size == 0 and part_size > 1\n part_size -= 1\n end\n end\n\n subnets = []\n iter = first\n\n parts.times do |i|\n iter_next = iter + (part_size - 1)\n\n # last part should be smaller\n iter_next = last if iter_next > last or i + 1 == parts\n\n subnets << Subnet.new(iter, iter_next)\n iter = iter_next + 1\n end\n\n subnets\n end",
"def pieces_get(piece_key, color)\n res = []\n @pieces[color].each do |v|\n if v.type_piece == piece_key \n res << v\n end\n end\n return res\n end",
"def get_all_org_units_by_type_id(outype_id)\n path = \"/d2l/api/lp/#{$lp_ver}/orgstructure/6606/children/?ouTypeId=#{outype_id}\"\n _get(path)\nend"
] | [
"0.59806436",
"0.5977293",
"0.57885796",
"0.5783526",
"0.5768775",
"0.5576938",
"0.5576938",
"0.55630565",
"0.55246824",
"0.55246824",
"0.55246824",
"0.55094117",
"0.54108685",
"0.53605956",
"0.5333895",
"0.5328548",
"0.52733123",
"0.52691305",
"0.5267567",
"0.525953",
"0.5238273",
"0.52196145",
"0.5213066",
"0.5175532",
"0.51452124",
"0.5131267",
"0.5112637",
"0.51017207",
"0.5090379",
"0.50701165",
"0.50551337",
"0.5053911",
"0.5049129",
"0.50483733",
"0.5019621",
"0.50116444",
"0.50017047",
"0.49784067",
"0.4975473",
"0.4970945",
"0.49673706",
"0.4946802",
"0.49424917",
"0.49371153",
"0.4936345",
"0.49249822",
"0.49208772",
"0.49197033",
"0.49099737",
"0.49097085",
"0.49084818",
"0.49050117",
"0.49022314",
"0.4899981",
"0.48990884",
"0.4897768",
"0.48946705",
"0.48850083",
"0.48823214",
"0.4881215",
"0.4877399",
"0.48729587",
"0.4872667",
"0.48726222",
"0.48657137",
"0.48454344",
"0.48418808",
"0.4793753",
"0.47841665",
"0.47798246",
"0.47730732",
"0.4765188",
"0.476411",
"0.47634113",
"0.47595057",
"0.4758049",
"0.47495082",
"0.47489926",
"0.4746655",
"0.47446328",
"0.47440413",
"0.4738853",
"0.47365427",
"0.4732979",
"0.47257492",
"0.4725485",
"0.47224465",
"0.4721949",
"0.4719924",
"0.47160178",
"0.4714884",
"0.47142008",
"0.47093794",
"0.4703192",
"0.4692349",
"0.4681558",
"0.46792752",
"0.46483722",
"0.46448562",
"0.4634967"
] | 0.64470756 | 0 |
Append a part to ContentTypes | def append(part)
# Don't write the part again if it already exists ya dummy
return nil if exists? part
edit_xml do |xml|
xml.at_xpath('/xmlns:Types').tap do |types|
types << Nokogiri::XML::Node.new("Override", xml).tap do |n|
n['PartName'] = part.path
n['ContentType'] = part.class::CONTENT_TYPE
end
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_content_type(extension, type); end",
"def << part\n @parts << part\n end",
"def add_part(part)\n @parts ||= Array.new\n @parts << part\n end",
"def <<(content)\n @parts << content\n end",
"def << part\n case part\n when RDoc::Markup::Document then\n unless part.empty? then\n parts.concat part.parts\n parts << RDoc::Markup::BlankLine.new\n end\n when String then\n raise ArgumentError,\n \"expected RDoc::Markup::Document and friends, got String\" unless\n part.empty?\n else\n parts << part\n end\n end",
"def add_type\n @item.type = bibtex_type\n end",
"def add_part(part)\n if !body.multipart? && !self.body.decoded.blank?\n @text_part = Mail::Part.new('Content-Type: text/plain;')\n @text_part.body = body.decoded\n self.body << @text_part\n add_multipart_alternate_header\n end\n add_boundary\n self.body << part\n end",
"def add(content_type, attributes)\n _attributes = self.filter_attributes(content_type, attributes)\n\n entry = content_type.build_entry(_attributes)\n\n key = File.join(content_type.slug, entry._slug)\n\n self.items[key] = self.ids[entry._id] = entry\n end",
"def add(*types)\n types.each do |mime_type|\n if mime_type.kind_of? MIME::Types\n add(*mime_type.defined_types)\n else\n if @type_variants.include?(mime_type.simplified)\n if @type_variants[mime_type.simplified].include?(mime_type)\n warn \"Type #{mime_type} already registered as a variant of #{mime_type.simplified}.\" unless defined? MIME::Types::STARTUP\n end\n end\n add_type_variant(mime_type)\n index_extensions(mime_type)\n end\n end\n end",
"def addPart (method, url, headers, body, contentId = \"\")\n part = { :method => method, :url => url, :headers => headers, :body => body, :contentId => contentId }\n @parts.push(part)\n end",
"def <<( part )\n\t\tif part.is_a? Assembly\n\t\t\t@inventory[ part.id ] = part\n\n\t\telsif part.is_a? Template\n\t\t\t@templates[ part.id ] = part\n\t\tend\n\tend",
"def add_type(type)\n end",
"def add_content_items_to_collections context\n\n context[:all_metadata].select do |item|\n item[:file_type] == :content && (\n context[:status] == :preview || item['published'] )\n end.each do | item |\n context[( item['content_type'] + 's').to_sym ] ||= []\n context[( item['content_type'] + 's').to_sym ].push item\n end\n end",
"def add_content(content)\n @content = @content + content\n end",
"def add(content)\n raise NotImplementedError\n end",
"def add_type(mime_type, quiet = false)\n if !quiet and @type_variants[mime_type.simplified].include?(mime_type)\n warn(\"Type %s is already registered as a variant of %s.\" % [\n mime_type, mime_type.simplified ])\n end\n\n add_type_variant!(mime_type)\n index_extensions!(mime_type)\n end",
"def add_mime_types\n puts \"Updating Mime Types\"\n insert_into_file \"config/initializers/mime_types.rb\", :after => \"# Be sure to restart your server when you modify this file.\" do <<EOF\nMime::Type.register_alias \"text/plain\", :refworks_marc_txt\nMime::Type.register_alias \"text/plain\", :openurl_kev\nMime::Type.register \"application/x-endnote-refer\", :endnote\nMime::Type.register \"application/marc\", :marc\nMime::Type.register \"application/marcxml+xml\", :marcxml, \n [\"application/x-marc+xml\", \"application/x-marcxml+xml\", \n \"application/marc+xml\"]\nEOF\n end \n end",
"def add_type(type)\n\n # nothing to be done\n end",
"def add_type(type)\n\n # nothing to be done\n end",
"def concat parts\n self.parts.concat parts\n end",
"def add(attributes)\n slug = attributes['slug']\n\n attributes.delete('entries_custom_fields').each do |_attributes|\n _attributes = _attributes.delete_if { |k, v| v.blank? || %w(id updated_at created_at).include?(k) }\n\n # TODO: select options\n\n (attributes['fields'] ||= []) << _attributes\n end\n\n unless self.items.key?(slug)\n self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)\n end\n\n self.items[slug]\n end",
"def set_content_type old_type, old_resource_type, new_type, new_resource_type\n xml=self.ng_xml\n xml.search('/contentMetadata[@type=\\''+old_type+'\\']').each do |node|\n node['type']=new_type\n xml.search('//resource[@type=\\''+old_resource_type+'\\']').each do |resource|\n resource['type']=new_resource_type\n end\n end\n self.content=xml.to_s\n end",
"def part_type=(value)\n\n end",
"def add_element_to_section(section,type,data)\n url = @base + \"elements.json\"\n params = {\"item\"=>{\"element_type\"=> type, \"data\"=>data, \"container_type\"=>\"ExperimentProcedure\", \"container_id\"=>section[\"id\"], \"field_name\"=>section[\"section_type\"]},token: @token}\n response = JSON.parse(RestClient.post(url,params))\nend",
"def add_item_with_content(content,insert_position=nil)\n # aggregates = get_values('aggregates')\n # aggregates << content\n # set_value('aggregates',aggregates)\n aggregates = self.aggregates.dup\n aggregates << content\n self.aggregates = aggregates\n RDFTypes::VirtualCollectionItemRDF.create(:content => content, :virtual_collection => self, :insert_position => insert_position)\n end",
"def add(*types)\n __types__.add(*types)\n end",
"def add_element_to_section(section,type,data)\n url = @base + \"/api/v1/elements.json\"\n params = {\"item\"=>{\"element_type\"=> type, \"data\"=>data, \"container_type\"=>\"ExperimentProcedure\", \"container_id\"=>section[\"id\"], \"field_name\"=>section[\"section_type\"]},token: @token}\n response = JSON.parse(RestClient.post(url,params))\nend",
"def push *parts\n self.parts.concat parts\n end",
"def assign_body_parts(body)\n body.parts.each do |part|\n if part.multipart?\n assign_body_parts(part)\n else\n @body[part.header[\"content-type\"].sub_type] = part.body if \n part.header[\"content-type\"].main_type == \"text\"\n end #if\n end #do\n end",
"def add(*types)\n quiet = ((types.last == :silent) or (types.last == true))\n\n types.each do |mime_type|\n case mime_type\n when true, false, nil, Symbol\n nil\n when MIME::Types\n variants = mime_type.instance_variable_get(:@type_variants)\n add(*variants.values.flatten, quiet)\n when Array\n add(*mime_type, quiet)\n else\n add_type(mime_type, quiet)\n end\n end\n end",
"def add_extension(extension)\n @parts[-1] += extension\n self\n end",
"def maybe_add_mimetype(params)\n\n mime_type_other = params[:mime_type_other]\n\n if !mime_type_other.blank?\n\n # Check to see if it already exists before creating a new mimetype:\n m = Mimetype.find_by_type_string(mime_type_other)\n if m.nil?\n m = Mimetype.new(type_string: mime_type_other)\n if m.valid?\n m.save\n end\n end\n\n params[:form][:mimetype_id] = m.id\n end\n end",
"def add entity\n raise Error.new('can only add Media objects') unless entity.is_a? Media\n @body.add(entity)\n end",
"def add(data_type, extension)\n @extensions_for[data_type.to_s] << extension\n end",
"def push *texts\n self.parts.concat texts\n end",
"def add_attribute_to_type\n check_type_exists\n type_content = File.read(type_path)\n unless parameter_in_type?(type_content)\n type_content.sub!(END_PARAMETER_BLOCK,\"\\t\\t#{@attribute_type} :#{@attribute_name}\\n#{END_PARAMETER_TEXT}\")\n save_file(type_path, type_content)\n Puppet.notice \"#{@attribute_type.capitalize} #{@attribute_name} added to #{type_path}\"\n else\n Puppet.notice \"#{@attribute_type.capitalize} #{@attribute_name} already in #{type_path}\"\n end\n end",
"def push *parts\n @parts.concat parts\n end",
"def perform_extend(subtype)\n Domgen.error(\"#{container_kind} #{name} attempting to extend final #{container_kind} #{extends}\") if self.final?\n self.mark_subtypes_as_obsolete\n self.direct_subtypes << subtype\n end",
"def register_for_content_type(content_type = nil, klass: nil)\n klass ||= self\n raise ArgumentError, \"#{klass} must be a class constant!\" unless klass.respond_to?(:new)\n\n content_type ||= WCC::Contentful::Helpers.content_type_from_constant(klass)\n\n _registry[content_type] = klass\n end",
"def add_type(uri, type, data)\n triple = RDF::Statement.new(RDF::URI.new(uri.to_s), RDF.type, RDF::URI.new(@types[type]))\n data << triple\n end",
"def add_chunk(type, pkey, fields = {})\n raise ArgumentError, \"Chunks can be added only if type is :patch\" unless @type.eql?(:patch)\n @chunks[pkey.to_yaml] = { :type => type, :pkey => pkey, :fields => fields}\n end",
"def add_part_group_taxon()\n new_taxons = @product_row[:category].to_s.split(\",\")\n new_taxons.each do |category|\n category.strip!\n my_taxon = Spree::Taxon.where(\"description=?\", category)\n my_taxonomy = Spree::Taxon.where(\"description=?\", category.split('-')[0])\n if(my_taxon.length === 0 || my_taxonomy.length === 0)\n @errors << { :part_number => @product_row[:name], :condition => @product_row[:condition], :message => \"Unable to identify proper part group for \" + @product_row[:category].to_s }\n end\n @new_product.taxons << my_taxon\n @new_product.taxons << my_taxonomy\n end\n\n # add package taxon\n if(@product_row[:package] && @product_row[:package].to_s.downcase === \"y\")\n package_taxon = Spree::Taxon.where(\"name=?\", \"Packages and Assemblies\")\n @new_product.taxons << package_taxon\n end\n end",
"def rewrite_body(message, content_type:, parts: [])\n message.body = nil\n message.content_type = content_type\n parts.each { |p| message.add_part(p) }\n end",
"def add(attributes)\n slug = attributes['slug']\n\n # TODO: raise an error if no fields\n\n attributes.delete('fields').each_with_index do |_attributes, index|\n hash = { name: _attributes.keys.first, position: index }.merge(_attributes.values.first)\n\n if options = hash.delete('select_options')\n hash['select_options'] = self.sanitize_select_options(options)\n end\n\n (attributes['fields'] ||= []) << hash\n end\n\n attributes[:mounting_point] = self.mounting_point\n\n unless self.items.key?(slug)\n self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)\n end\n\n self.items[slug]\n end",
"def add_subtypes_to_definitions\n # to augment all types definitions\n lolsoap_parser.types.each_value do |content|\n add_subtypes(content[:elements])\n end\n # we have to augment operations because some Requests are abstract, for instance:\n # ReportRequest which can be AccountPerformanceReportRequest etc...\n lolsoap_parser.operations.each_value do |content|\n content[:input][:body].each do |full_name|\n add_subtypes(lolsoap_parser.elements[full_name][:type][:elements])\n end\n end\n @grouped_subtypes = nil # we can reset this as its not needed anymore\n end",
"def add(*types)\n @__types__.add(*types)\n end",
"def add_type(type)\n\n # does nothing, types are differentiated by the 'typ' column\n end",
"def add(content)\n if ( (! content.kind_of?(BioInterchange::TextMining::Content)) && (! content.kind_of?(BioInterchange::TextMining::ContentConnection)) )\n raise BioInterchange::Exceptions::ImplementationModelError, 'Content has to be of kind BioInterchange::TextMining::Content or kind BioInterchange::TextMining::ContentConnection' \n end\n @content << content\n end",
"def parts(type)\n xml.xpath(\"//xmlns:Override[@ContentType='#{type}']\").map{ |n| n['PartName'] }\n end",
"def []=(content_type, klass); end",
"def _append_element(type, param, noparse=false, str='')\n\t\tif(\n\t\t\t@contents[@content_index += 1] = SifterElement.new(\n\t\t\t\tself, type, param, \n\t\t\t\t((type == 'EMBED' )? param.to_int: @embed_flag ), \n\t\t\t\t((type == 'NOBREAK')? 1 : @nobreak_flag)\n\t\t\t)\n\t\t)\n\t\t\tif(!noparse)\n\t\t\t\tif(!@contents[@content_index]._parse())\n\t\t\t\t\treturn false\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t@contents[@content_index]._append_text(str) if(str && str != '')\n\t\t\treturn true\n\t\tend\n\n\t\treturn false\n\tend",
"def add_extend ext\n add_to @extends, ext\n\n ext\n end",
"def duplicate_part(part)\n duplicate = part.dup\n duplicate.add_content_id(part.content_id) unless part.content_id.nil?\n duplicate\n end",
"def create\n parms = document_part_params.to_h.deep_dup.symbolize_keys\n parms[:document_id] = @document_section.document_id\n parms[:type] = 'DocumentPart::HtmlContent' if parms[:type].blank?\n @document_part = @document_section.parts.create(parms)\n redirect_to edit_admin_document_document_section_document_part_path(@document, @document_section, @document_part), notice: 'Content was successfully updated.' if @document_part.valid?\n end",
"def add_content(cc)\n @current_contents << cc\n end",
"def add_type(type)\n\n # does nothing, types are differentiated by the 'typ' column\n end",
"def add(doc, uri=nil, content_type=nil)\n return _put_doc(doc, uri, content_type)\n end",
"def add(type)\n merge(type.registry.minimal(type.name))\n nil\n end",
"def add_additional(name, type, klass)\n self.payload += self.add_record(name, type, klass).encode\n self.additional_rr += 1\n end",
"def add_category(content_array, type)\n content_array.unshift(create_node(type: 'atom:category', attrs: Atom::CATEGORY[type.to_sym]).to_s) if Atom::CATEGORY[type.to_sym]\n end",
"def add_thing( thing )\n data = {\n token: @applicationToken,\n name: thing.name,\n display_name: thing.display_name\n }\n if( thing.product_type.length > 0 )\n data[:product_type] = thing.product_type\n end\n\n @httpHelper.post_data( 'thing', data )\n end",
"def << x\n # $stderr.puts \" #{self.object_id} << #{x.class} #{x.id}\"\n case x\n when Content, Content::Version\n add_content x\n when ContentKey, ContentKey::Version\n add_content_key x\n else\n raise ArgumentError, \"expected Content or ContentKey\"\n end\n self\n end",
"def content_type=(new_content_type)\n write_attribute(:content_type, new_content_type)\n end",
"def set(type, content)\n grit.git.put_raw_object(content, type.to_s)\n end",
"def new_part\n self.parts << self.current_part if !self.current_part.nil?\n self.current_part = Rain::DocPart.new\n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element)\n\n if element.name == 'item'\n super(DiscoItem::new.import(element))\n else\n super(element)\n end\n\n else\n super(element)\n end\n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element) && (element.name == 'item')\n item = RosterItem::new.import(element)\n super(item)\n else\n super(element)\n end\n end",
"def append more\n case more\n when String then\n @reference += more\n @rdoc += more\n when RDoc::RD::Inline then\n @reference += more.reference\n @rdoc += more.rdoc\n else\n raise \"unknown thingy #{more}\"\n end\n\n self\n end",
"def addMetadataType\n begin\n # Name of the metadatatype to be added\n name = params[:metadatatypename].to_s.strip.downcase\n value_type = params[:value_type].to_s.strip.downcase\n\n if value_type == \"\"\n value_type = \"string\"\n elsif value_type != \"string\" && value_type != \"float\" && value_type != \"date\" && value_type != \"datetime\"\n render :text => \"Invalid value_type\", :status => 404\n return\n end\n\n # Check that type doesn't exist already\n # @@existing_metadata_types listed in the beginning of file\n if MetadataType.find_by_name(name) or @@existing_metadata_types.include?(name)\n render :text => \"Metadatatype already exists\", :status => 200\n return\n end\n\n # Create new type\n @newtype = MetadataType.create(:name => name, :value_type => value_type)\n render :text => \"Metadatatype created\", :status => 201\n return\n rescue => e\n puts \"Error in adding metadatatype: #{e.to_s}\".background(:red)\n render :text => \"Conflict\", :status => 409\n return\n end\n end",
"def register_mime_types(types)\n cr = Fl::Framework::Attachment::ClassRegistry.registry\n\n types.each do |tk, tv|\n av = (tv.is_a?(Array)) ? tv : [ tv ]\n av.each do |orm|\n cr.register(tk, self, orm)\n end\n end\n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element) && (element.name == 'item')\n super(XRosterItem::new.import(element))\n else\n super(element)\n end\n end",
"def add_header_val(type_string)\n add(MediaType.parse(type_string))\n rescue ArgumentError\n raise \"Invalid media type\"\n end",
"def << tagspec\n @marcfieldspecs << tagspec\n end",
"def adapt_doc_string(doc_string_ast)\n adapted_doc_string = super(doc_string_ast)\n\n adapted_doc_string['content_type'] = doc_string_ast[:mediaType]\n\n adapted_doc_string\n end",
"def content_type=(new_content_type)\n @content_type = new_content_type\n end",
"def add_content(content)\n @contents[content.checksum] = content\n end",
"def add_part\n room = Room.find(params[:room_id])\n story = Story.find(room.story_id)\n passage = story.passage\n passage << ' ' << params[:part]\n story.update(passage: passage)\n\n ActionCable.server.broadcast(\"room_#{params[:room_id]}\", {part: params[:part], action: 'room_add_part'})\n end_turn(params[:room_id])\n\n render json: { status: :ok }\n end",
"def add entity\n @body.push(entity)\n end",
"def content_types=(value)\n @content_types = value\n end",
"def add(type, description, options={})\n type = type.downcase\n add_item construct_item(type, description, options)\n end",
"def add(name, type, offset = nil)\n if type.respond_to?(:to_str) || type.respond_to?(:to_sym)\n type = registry.build(type.to_s)\n end\n @fields << [name.to_s, type, offset]\n end",
"def add_content_type\n header[:content_type] = 'text/plain'\n end",
"def add(new_body)\n @bodies << new_body\n @bodies\n end",
"def add_path_part(name, rel_path=nil, expected_type=nil)\n if not name.kind_of? String\n raise ArgumentInvalidTypeError.new 'name', name, String\n end\n \n if has_path_part? name\n raise ArgumentError \"path part #{name} has already been added\"\n end\n \n rel_path_parts = (not rel_path.kind_of? String) ? [] : rel_path.split('.')\n \n if (not rel_path_parts.empty?) and has_path_part?(rel_path_parts[0])\n rel_path = \"\"\n rel_path << self[rel_path_parts[0]].full_rel_path\n if (rel_path_parts.length > 1)\n rel_path << \".\" << rel_path_parts.last(rel_path_parts.length - 1).join('.')\n end\n end\n \n path_part = create_path_part(name, self, rel_path, expected_type)\n \n @child_path_parts[path_part.name] = path_part\n return path_part\n end",
"def add_relation\n rel = @bib.relation.detect { |r| r.type == \"partOf\" }\n if rel\n title_main = rel.bibitem.title.detect { |t| t.type == \"main\" }\n @item.booktitle = title_main.title.content\n end\n end",
"def add_field(type, value)# {{{\n t = TLV.new(2,2)\n t.type = type\n t.value = value\n t.length = 4 + value.length\n self.payload += t.encode \n end",
"def register_mime_types\n types = mime_types.map(&:to_s)\n exts = file_extensions.map(&:to_sym)\n type = types.shift\n ext = exts.shift\n __debug_mime(binding) do\n { type: type, ext: ext, types: types, exts: exts }\n end\n return unless type && ext\n Mime::Type.register(type, ext, types, exts) # TODO: needed?\n Marcel::MimeType.extend(type, extensions: file_extensions.map(&:to_s))\n end",
"def append(id, content, options = AppendOptions.new) end",
"def append(content)\n\t\t\tFile.open(path,'a'){|target| target << content}\n\t\t\tnew_file = FileAry.new(path)\n\t\t\t@read = new_file.read\n\t\t\t@head = read.lines.first\n\t\t\t@lines = read.lines\n\t\tend",
"def type_specific_part\n return @type_specific_part unless @type_specific_part.nil?\n io = type_specific_part_raw_with_io._io\n _pos = io.pos\n io.seek(0)\n case common_part.header_type\n when 8\n @type_specific_part = TypeSpecificPartType8.new(io, self, @_root)\n when 9\n @type_specific_part = TypeSpecificPartType9.new(io, self, @_root)\n end\n io.seek(_pos)\n @type_specific_part\n end",
"def parts\n @doc.content_types.parts Slide::CONTENT_TYPE\n end",
"def content_type=(content_type); end",
"def add_to_asset_box(box, *items)\n box = (box.present? ? box.to_s : 'assets')\n boxes = box.pluralize\n items = [items].flatten.compact\n\n if items.present? && items.any? { |obj| !obj.kind_of?(Effective::Asset) }\n raise ArgumentError.new('add_to_asset_box expects one or more Effective::Assets, or an Array of Effective::Assets')\n end\n\n if box == boxes # If we're adding to a pluralized box, we want to add our attachment onto the end\n pos = attachments.select { |attachment| attachment.box == boxes }.last.try(:position).to_i + 1\n else # If we're adding to a singular box, we want our attachments to be on the front\n pos = attachments.to_a.find { |attachment| attachment.box == boxes }.try(:position).to_i\n\n # Push all the attachments forward\n attachments.each { |att| att.position = (att.position + items.length) if att.box == boxes }\n end\n\n # Build the attachments\n items.each_with_index do |item, x|\n attachment = self.attachments.build(:position => (pos+x), :box => boxes)\n\n attachment.attachable = self\n attachment.asset = item\n end\n\n attachments.to_a.sort_by! { |attachment| attachment.position }\n\n true\n end",
"def add(path, data, ctype=DEFAULT_CTYPE)\n # FIXME: determine if ADD or UPDATE EVENT\n # evt = File.exist? @content_tree.node_path(path)\n # FIXME: should this always be create-or-update? what about replace=false?\n n = @content_tree.add(path, data, ctype)\n notify(EVENT_ADD, path, ctype)\n n\n end",
"def add_format(format)\n\n unless Mime::Type.lookup_by_extension format\n\n raise ArgumentError, \"Please register the #{format} mime type with `Mime::Type.register`\"\n\n end\n\n @formats << format unless formats.include? format\n\n formats\n\n end",
"def log_content_type(type)\n File.open(Path + \"/content.log\", \"a\") {|f| f << type + \"\\n\"}\nend",
"def set_Part(value)\n set_input(\"Part\", value)\n end",
"def set_Part(value)\n set_input(\"Part\", value)\n end",
"def set_Part(value)\n set_input(\"Part\", value)\n end",
"def set_Part(value)\n set_input(\"Part\", value)\n end"
] | [
"0.68168235",
"0.67053103",
"0.66667956",
"0.647054",
"0.6213678",
"0.60317475",
"0.6005277",
"0.59842056",
"0.59021443",
"0.5891802",
"0.57783264",
"0.57701594",
"0.57565355",
"0.5729698",
"0.5664052",
"0.55524606",
"0.5550688",
"0.5471156",
"0.5471156",
"0.5463317",
"0.54603744",
"0.5456627",
"0.5441609",
"0.54393035",
"0.5437041",
"0.5422453",
"0.5417971",
"0.5414205",
"0.5391835",
"0.5376529",
"0.5376341",
"0.53733736",
"0.5346527",
"0.53402144",
"0.5336657",
"0.5324056",
"0.5313301",
"0.53034306",
"0.5268323",
"0.5262292",
"0.52617556",
"0.52503985",
"0.5227386",
"0.5221165",
"0.52199745",
"0.5216675",
"0.52127343",
"0.52099323",
"0.5198223",
"0.5189668",
"0.5186523",
"0.5185001",
"0.516956",
"0.51695234",
"0.5168376",
"0.5165836",
"0.51633",
"0.5150139",
"0.5146626",
"0.5145005",
"0.5144052",
"0.5109929",
"0.5085553",
"0.50772136",
"0.5055441",
"0.5051374",
"0.50425977",
"0.50425655",
"0.5040058",
"0.5026933",
"0.5022626",
"0.5016742",
"0.50118494",
"0.500915",
"0.49873552",
"0.49782145",
"0.49625883",
"0.4958079",
"0.4949271",
"0.4940411",
"0.4936137",
"0.49327478",
"0.4923473",
"0.48931322",
"0.48925498",
"0.48854628",
"0.4879635",
"0.4871089",
"0.48659554",
"0.48584732",
"0.48440412",
"0.48430046",
"0.4838552",
"0.48372734",
"0.48342177",
"0.4830766",
"0.48303404",
"0.48303404",
"0.48303404",
"0.48303404"
] | 0.780444 | 0 |
Test if the part already exists so we don't write it multiple times. | def exists?(part)
!! xml.at_xpath("//xmlns:Override[@ContentType='#{part.class::CONTENT_TYPE}' and @PartName='#{part.path}']")
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def duplicate_part(part)\n duplicate = part.dup\n duplicate.add_content_id(part.content_id) unless part.content_id.nil?\n duplicate\n end",
"def already_stored?\n !file_uniqueness\n end",
"def add_if_not_exists()\n\tif record_exists()\n\t\tprintf(\"EXISTS %s\\n\",self.digest)\n\t\treturn 0\n\tend\n\tsave()\n\treturn 1\nend",
"def duplicate?\n\t\tother = Ng2::WordDetail.find(@word).last\n\t\t!other.nil? &&\n\t\tother.file_path == self.file_path &&\n\t\tother.line_no == self.line_no &&\n\t\tother.word_no == self.word_no\n\tend",
"def pairing_already_exists\n\t\tpairing = Pairing.find_by(wine_id: self.wine_id, cookie_id: self.cookie_id)\n\t\tif pairing\n\t\t\terrors.add(:pairing, \"Already Exists. Try Creating a Different Pairing\")\n\t\tend\n\tend",
"def exists!\n @exists = true\n end",
"def duplicate?\n @duplicate == true\n end",
"def write_unless_exists(name, value)\n !exist?(name).tap do |exists|\n write(name, value) unless exists\n end\n end",
"def test_reuse_existing_chunks_when_append\n CheckFile @writer, @ioservice, @adlers, 'test content', ['test ', 'conte', 'nt']\n CheckFile @writer, @ioservice, @adlers, 'test content updated', ['test ', 'conte', 'nt', ' upda', 'ted']\n end",
"def entry_exists?(clear_error_message = true)\n self.clear_error_message if clear_error_message\n\n pn = PartNumber.get_part_number(self)\n exists = pn != nil && pn.board_design_entry != nil\n self.set_error_message('The entry already exists') if exists\n exists\n end",
"def test_existence\n\n # Define and store a new part number.\n pn = PartNumber.initial_part_number\n pn.pcb_prefix = '600'\n pn.pcb_number = '123'\n pn.pcb_dash_number = 'a0'\n pn.pcba_prefix = '600'\n pn.pcba_number = '233'\n pn.pcba_dash_number = 'a0'\n \n assert(!pn.exists?)\n assert(!pn.entry_exists?)\n assert_nil(pn.error_message)\n pn.get_id\n assert_nil(pn.id)\n assert_nil(PartNumber.get_part_number(pn))\n pn.save\n \n assert(pn.exists?)\n assert_not_nil(PartNumber.get_part_number(pn))\n assert_equal(@msg_pcb_pcba_exists, pn.error_message)\n assert_equal(pn.id, PartNumber.get_part_number(pn).id)\n \n assert(!pn.entry_exists?)\n board_design_entry = BoardDesignEntry.new(:part_number_id => pn.id,\n :lead_free_device_names => '',\n :originator_comments => '',\n :input_gate_comments => '')\n board_design_entry.save\n assert(pn.entry_exists?)\n assert_equal('The entry already exists', pn.error_message)\n \n \n # Try the same part number that was just created.\n new_pn = PartNumber.initial_part_number\n new_pn.pcb_prefix = '600'\n new_pn.pcb_number = '123'\n new_pn.pcb_dash_number = 'a0'\n new_pn.pcba_prefix = '600'\n new_pn.pcba_number = '233'\n new_pn.pcba_dash_number = 'a0'\n\n assert_equal(pn.id, new_pn.get_id)\n assert(new_pn.exists?)\n assert_equal(@msg_pcb_pcba_exists, new_pn.error_message)\n assert(new_pn.pcb_pn_exists?)\n assert_equal(@msg_pcb_exists_pcb, new_pn.error_message)\n assert(new_pn.pcba_pn_exists?)\n assert_equal(@msg_pcba_exists_pcba, new_pn.error_message)\n \n \n # Try a new part number with a PCBA that is the same as an existing\n # part number PCBA component\n new_pn = PartNumber.initial_part_number\n new_pn.pcb_prefix = '700'\n new_pn.pcb_number = '123'\n new_pn.pcb_dash_number = 'b0'\n new_pn.pcba_prefix = '600'\n new_pn.pcba_number = '233'\n new_pn.pcba_dash_number = 'a0'\n\n assert(new_pn.exists?)\n assert_equal(@msg_pcba_exists_pcba, new_pn.error_message)\n assert(!new_pn.pcb_pn_exists?)\n assert_equal(nil, new_pn.error_message)\n assert(new_pn.pcba_pn_exists?)\n assert_equal(@msg_pcba_exists_pcba, new_pn.error_message)\n\n\n # Try a new part number with a PCBA that is the same as an existing\n # part number PCB component\n new_pn = PartNumber.initial_part_number\n new_pn.pcb_prefix = '600'\n new_pn.pcb_number = '888'\n new_pn.pcb_dash_number = 'a0'\n new_pn.pcba_prefix = '600'\n new_pn.pcba_number = '123'\n new_pn.pcba_dash_number = 'a0'\n\n assert(new_pn.exists?)\n assert_equal(@msg_pcba_exists_pcb, new_pn.error_message)\n assert(!new_pn.pcb_pn_exists?)\n assert_equal(nil, new_pn.error_message)\n assert(new_pn.pcba_pn_exists?)\n assert_equal(@msg_pcba_exists_pcb, new_pn.error_message)\n\n\n # Try a new part number with a PCB that is the same as an existing\n # part number PCBA component\n new_pn = PartNumber.initial_part_number\n new_pn.pcb_prefix = '600'\n new_pn.pcb_number = '233'\n new_pn.pcb_dash_number = 'a0'\n new_pn.pcba_prefix = '600'\n new_pn.pcba_number = '923'\n new_pn.pcba_dash_number = 'a0'\n\n assert(new_pn.exists?)\n assert_equal(@msg_pcb_exists_pcba, new_pn.error_message)\n assert(new_pn.pcb_pn_exists?)\n assert_equal(@msg_pcb_exists_pcba, new_pn.error_message)\n assert(!new_pn.pcba_pn_exists?)\n assert_equal(nil, new_pn.error_message)\n\n \n # Try a new part number with a PCB that is the same as an existing\n # part number PCB component\n new_pn = PartNumber.initial_part_number\n new_pn.pcb_prefix = '600'\n new_pn.pcb_number = '123'\n new_pn.pcb_dash_number = 'a0'\n new_pn.pcba_prefix = '666'\n new_pn.pcba_number = '999'\n new_pn.pcba_dash_number = 'f8'\n\n assert(new_pn.exists?)\n assert_equal(@msg_pcb_exists_pcb, new_pn.error_message)\n assert(new_pn.pcb_pn_exists?)\n assert_equal(@msg_pcb_exists_pcb, new_pn.error_message)\n assert(!new_pn.pcba_pn_exists?)\n assert_equal(nil, new_pn.error_message)\n \n eco_pn = part_numbers(:eco_number)\n retrieved_eco_pn = PartNumber.get_part_number(eco_pn)\n\n end",
"def is_existing?()\n #p \"randomize is_existing flag\"\n false\n end",
"def path_is_unique\n return true if self.mp3.file.blank?\n\n # Guess what the audio path will be before it's actually saved there.\n # This is predictable for uploaded audio.\n # This could potentially fail if someone was uploading audio at exactly\n # midnight and some audio already existed for the next day.\n path = File.join(\n AUDIO_PATH_ROOT,\n self.store_dir,\n self.filename\n )\n\n if File.exist?(path)\n self.errors.add(:mp3, \"A file with that name already exists; \" \\\n \"please rename your local audio file and try again. \" \\\n \"If you are trying to replace the audio file, first delete the \" \\\n \"old audio.\")\n end\n end",
"def exist?\n # shouldn't force network connections just to check if content exists\n # only check that the path is not empty\n !path.to_s.empty?\n end",
"def exist?\n # shouldn't force network connections just to check if content exists\n # only check that the path is not empty\n !path.to_s.empty?\n end",
"def exist?\n true\n end",
"def previously_existed?\n true\n end",
"def exist\n\treturn true\n end",
"def save_exists?(index)\n File.exists?(DataManager.make_filename(index-1))\n end",
"def exist?\n @lock.synchronize { valid? }\n end",
"def check_or_create_for!(hash, key)\n hash[key] = \"\" unless hash.include?(key)\n end",
"def exists?\n begin\n partition= resource[:name]\n device=partition[0,(partition.length-1)]\n if File.exist?(partition)\n true\n else\n false\n end\n end\n end",
"def exist?\n nil\n end",
"def saved_already?\n @id != \"\" && @id != nil\n end",
"def test_reuse_existing_chunks_when_prepend\n CheckFile @writer, @ioservice, @adlers, 'test content', ['test ', 'conte', 'nt']\n CheckFile @writer, @ioservice, @adlers, 'a new test content', ['a new', ' ', 'test ', 'conte', 'nt']\n end",
"def uuid_overwrite?\n @uuid_overwrite\n end",
"def guid_already_exists?\n return Entry.where(feed_id: self.feed_id, guid: self.guid).exists?\n end",
"def exists?\n !new? && self.class.exists?(id, prefix_options)\n end",
"def exists?; end",
"def duplicate?(new_seg)\n @segs.each do |seg|\n return true if new_seg == seg\n end\n false\n end",
"def exists?\r\n !new? && self.class.exists?(id, prefix_options)\r\n end",
"def exist?\n !!@exist\n end",
"def exist?\n !!@exist\n end",
"def continue_on_exists_proc; end",
"def ensure_exists(sketch)\n puts \"Couldn't find: #{sketch}\" and exit unless FileTest.exist?(sketch)\n end",
"def exists?\n persistent? && (filename && filename.exist?)\n end",
"def existent; end",
"def part?(name)\n !part(name).nil?\n end",
"def check_for_duplicate_name\n # See if there are any of this name in the database\n unless Participant.find(:all, :conditions => ['LOWER(name) = ?', self.name.downcase]).blank?\n # If we've already added a digit to the end\n if self.name =~ /\\b[0-9]+$/\n self.name.gsub!(/[0-9]+$/) do |digit|\n digit.to_i + 1\n end\n else\n # Add a digit to the end\n self.name += \" 1\"\n end\n\n # Check again\n check_for_duplicate_name\n end\n end",
"def existing?\n @existing\n end",
"def exists?\n\t\treturn false\n\tend",
"def exist?\n !count.zero?\n end",
"def should_generate_new_friendly_id?\n slug.blank? || name_changed?\n end",
"def exists?\n false\n end",
"def exists?\n false\n end",
"def ensure_exists\n create unless Dir.exist? path\n end",
"def add_stored(entry, src_path, &continue_on_exists_proc); end",
"def exists?\n [email protected]? && @exists\n end",
"def exists?\n [email protected]? && @exists\n end",
"def exists?\n [email protected]? && @exists\n end",
"def suspend_file_exists?\n File.file? File.join(path, \"#{@name}.vmem\")\n end",
"def suspend_file_exists?\n File.file? File.join(path, \"#{@name}.vmem\")\n end",
"def destination_file_exist?\n File.exist?(final_destination_path)\n end",
"def should_generate_new_friendly_id?\n slug.blank?\n end",
"def exists?\n [email protected]? && @exists\n end",
"def exists?\n [email protected]? && @exists\n end",
"def exists?\n return File.exists?(\"/tmp/cloud-#{resource[:name]}\")\n end",
"def exists?\n return File.exists?(\"/tmp/cloud-#{resource[:name]}\")\n end",
"def exists?\n return File.exists?(\"/tmp/cloud-#{resource[:name]}\")\n end",
"def fcreates(fname sname)\n if fexistf fname\n if not eval \"$#{fname}['#{fname},slots'].member? sname\"\n eval \"${fname}['#{fname},slots'].add sname\"\n eval \"${fname}['#{sname},facets'] = Set.new\"\n return true\n else \n return false\n end\n else\n return false\n end\nend",
"def resource_exists?\n reload!\n @exists = true\n rescue Google::Cloud::NotFoundError\n @exists = false\n end",
"def exists\n if @file && @mp3\n return true\n else\n return false\n end\n end",
"def should_generate_new_friendly_id?\n slug.blank?\n end",
"def is_new?\n !File.exists? @filename\n end",
"def shard_name_exists?( shard_name )\n !( definitions_by_name[ shard_name.to_sym ].nil? )\n end",
"def already_uploaded?\n false\n seen_before = Zaphod::PhotoStorage.get(\"seen_id_#{@post_id}\",\"recommendation\")\n if seen_before && seen_before == @post_id\n @log.debug(\"already uploaded ID #{seen_before}... skipping\")\n true\n end\n end",
"def exist?\n File.exist? fullpath\n end",
"def field_exists?(storage_name, field_name)\n true\n end",
"def exist?\n not self.name.nil?\n end",
"def already_taken?(layout)\n layout[\"unique\"] && page_with_layout_existing?(layout[\"name\"])\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def exists?\n @exists == true\n end",
"def exists?(clear_error_message = true)\n\n exists = false\n self.clear_error_message if clear_error_message\n\n if PartNumber.get_part_number(self) != nil\n if self.new?\n self.set_error_message('The supplied PCB and PCBA Part Number is ' +\n 'already in the database')\n else\n self.set_error_message('The supplied PCB Part Number already exists as' +\n ' a PCB Part Number in the database - ' +\n 'YOUR PART NUMBER WAS NOT CREATED')\n end\n exists = true\n end\n\n exists = exists || self.pcb_pn_exists?(clear_error_message)\n exists = (exists || self.pcba_pn_exists?(clear_error_message)) if self.new?\n\n return exists\n\n end",
"def exists?\n storage.exists?(id)\n end",
"def has_previous_part?\n index = part_index(current_part.slug)\n !! (index && index > 0)\n end",
"def unique?\n false\n end",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\t \n\tend",
"def exists?(part_infos, name)\n answer = false\n part_infos.each do |p|\n if p['name'].eql? name\n answer = true\n break\n end\n end\n answer\n end",
"def exist?\n !render_lines.nil?\n end",
"def exists?\n self.ensure == :present\n end",
"def exist?\n raise NotImplementedError\n end",
"def should_generate_new_friendly_id?\n\t\tslug.blank?\n\tend",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\tend",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\tend",
"def write_prep outfile\n return true unless File.exists? outfile\n\n # OK, file exists. See if we can clobber it\n if clobber?\n message { sprintf \"Overwriting existing file '%s'\", outfile }\n return true\n end\n\n message { sprintf \"Not overwriting existing file '%s'\", outfile }\n false\n end",
"def should_generate_new_friendly_id?\n\t name_changed?||self.slug.nil?\n\tend",
"def exist?\n up?\n end",
"def exist?\n up?\n end",
"def new_slug_needed?\n !slug || slug_text != slug.name\n end",
"def test_rack_doesnt_contain_enough_duplicate_letters\n [:A,:B,:A,:C].each{|x| @newTileRack.append(x)}\n assert_equal(false,@newTileRack.has_tiles_for?('AAAA'))\n end",
"def remove_should_check_existing?\n false\n end",
"def exists?\n !count.zero?\n end",
"def exists?\n !!@exists\n end",
"def already_there(target, full_target)\n File.exists?(full_target) and (!CHECKSUMS.key?(target) or Digest::MD5.file(full_target).hexdigest == CHECKSUMS[target])\n end",
"def write_to(path)\n if !File.exists?(path)\n FileUtils.mkdir_p(path)\n else\n raise FileExists.new(\"#{path} already exists\")\n end\nend",
"def remove_should_check_existing?\n true\n end",
"def modified_existing?\n false\n end",
"def path_exists?(path, create_if_not_exist = false)\n return true if path.empty?\n end"
] | [
"0.63035345",
"0.6251102",
"0.61025524",
"0.6090519",
"0.6068634",
"0.6061846",
"0.60607815",
"0.60209554",
"0.59828377",
"0.59471416",
"0.59217346",
"0.5902865",
"0.59002686",
"0.58318543",
"0.58318543",
"0.58080286",
"0.58072037",
"0.58004963",
"0.57955277",
"0.5778076",
"0.5765303",
"0.57384175",
"0.57340074",
"0.572327",
"0.56985915",
"0.56899285",
"0.5681219",
"0.5674781",
"0.56669647",
"0.56669074",
"0.56665224",
"0.5645939",
"0.5645939",
"0.5628241",
"0.5621001",
"0.5614806",
"0.5612213",
"0.56067336",
"0.55898476",
"0.55842394",
"0.5582361",
"0.5576301",
"0.5575916",
"0.5575223",
"0.5575223",
"0.5571993",
"0.5569394",
"0.5552005",
"0.5552005",
"0.5552005",
"0.55439657",
"0.55439657",
"0.5539439",
"0.5536831",
"0.5532803",
"0.5532803",
"0.5532228",
"0.5532228",
"0.5532228",
"0.5506009",
"0.55040455",
"0.5501108",
"0.5497876",
"0.54972225",
"0.549602",
"0.5489106",
"0.54889464",
"0.54832166",
"0.5482678",
"0.5472388",
"0.5470898",
"0.5470898",
"0.5470898",
"0.5470898",
"0.5468143",
"0.54622203",
"0.54619324",
"0.5461508",
"0.5461016",
"0.54468286",
"0.54294294",
"0.542888",
"0.5426336",
"0.54260314",
"0.5412881",
"0.5411966",
"0.5411966",
"0.54109126",
"0.5410795",
"0.5406245",
"0.5406245",
"0.5393277",
"0.5388",
"0.5387046",
"0.538147",
"0.5377927",
"0.5375661",
"0.5370348",
"0.53698355",
"0.53695834",
"0.53615874"
] | 0.0 | -1 |
GET /account/new GET /account/new.xml | def new
@account = Account.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @job }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = current_user.accounts.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = User::Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n \t@account = Account.new\n\t@navkey = \"account_new\"\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = Admin::Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n format.json { render :json => @account }\n end\n end",
"def new\n @account = current_user.accounts.build\n @help = \"New Account\"\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @external_account = ExternalAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @external_account }\n end\n end",
"def new\n @accounttype = Accounttype.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @accounttype }\n end\n end",
"def new\r\n @account = Account.new\r\n\r\n respond_to do |format|\r\n format.html # new.html.erb\r\n format.json { render json: @account }\r\n end\r\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @account, callback: params[:callback] }\n format.xml { render xml: @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account = Account.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @om_account = OmAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @om_account }\n end\n end",
"def new\n\n @account = Account.new(\n\n )\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account_transaction = AccountTransaction.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account_transaction }\n end\n end",
"def new\n @account = Account.new\n\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @account_membership = AccountMembership.new\n @account = Account.find params[:account_id]\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account_membership }\n end\n end",
"def create\n printf(\"create : %s/%s \\n\", params[\"name\"], params[\"password\"])\n @account = Account.new(:name => params[\"name\"], :email => params[\"email\"], :password => params[\"password\"])\n \n respond_to do |format|\n if @account.save\n printf(\"save OK\\n\")\n format.html { redirect_to(@account, :notice => 'Account was successfully created.') }\n format.xml { render :xml => @account, :status => :created, :location => @account }\n else\n printf(\"save FAIL\\n\")\n format.html { render :action => \"new\" }\n format.xml { render :xml => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n\t\t@account = Account.new\n\n\t\trespond_to do |format|\n\t\t\tformat.html # new.html.erb\n\t\t\tformat.json { render json: @account }\n\t\tend\n\tend",
"def new\n @dorm_account = DormAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @dorm_account }\n end\n end",
"def create\n @account = current_user.accounts.new(params[:account])\n\n respond_to do |format|\n if @account.save\n flash[:notice] = 'Account was successfully created.'\n format.html { redirect_to([current_user, @account]) }\n format.xml { render :xml => @account, :status => :created, :location => @account }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @admin = AdminAccount.find_by_id(session[:admin_id])\n @user_account = UserAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user_account }\n end\n end",
"def new\n @account = Account.new\n\t\[email protected]\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def new\n @personal = Personal.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @personal }\n end\n end",
"def new\n @balance = Balance.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @balance }\n end\n end",
"def new\n @account = Account.new\n authorize! :create, Account\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @account }\n end\n end",
"def create\n @account = current_account\n\n respond_to do |format|\n if @account.save\n flash[:notice] = 'User::Account was successfully created.'\n format.html { redirect_to(@account) }\n format.xml { render :xml => @account, :status => :created, :location => @account }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => new_vurl }\n end\n end",
"def new\n @user = User.new\n\n respond_to do |format|\n format.xml { render xml: @user}\n end\n end",
"def new\n logger.debug(\"Create a new user\")\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user }\n end\n end",
"def show\n printf(\"show : name %s\", params[\"id\"]);\n respond_to do |format| \n format.html { render :action => \"new\" }\n format.xml { render :xml => @account }\n end\n end",
"def new\n @admin = AdminAccount.find_by_id(session[:admin_id])\n @admin_account = AdminAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @admin_account }\n end\n end",
"def new\n @user = User.new\n render :xml => @user\n end",
"def new\n @tx = Tx.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @tx }\n end\n end",
"def new\n respond_with(account)\n end",
"def new\n @personal_account = PersonalAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @personal_account }\n end\n end",
"def new\n @recurso = Recurso.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @recurso }\n end\n end",
"def new\n @node = Node.scopied.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @node }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def new\n @person = Person.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @person }\n end\n end",
"def create\n @account = Admin::Account.new(params[:account])\n\n respond_to do |format|\n if @account.save\n flash[:notice] = 'Admin::Account was successfully created.'\n format.html { redirect_to(@account) }\n format.xml { render :xml => @account, :status => :created, :location => @account }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @identity = Identity.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @identity }\n end\n end",
"def new\n @resource = Resource.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @resource }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @title = \"New Company\"\n @company = Company.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @resource = Resource.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @resource }\n end\n end",
"def new\n @resource = Resource.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @resource }\n end\n end",
"def new\n @user_account = UserAccount.new\n @user_account.user = User.find(params[:user_id])\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @user_account }\n format.xml { render xml: @user_account }\n end\n end",
"def new\n @research = Research.new\n @page_title = \"Request research from White House 2 members\"\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @research.to_xml(:except => [:email]) }\n end\n end",
"def new\n @borrow = Borrow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @borrow }\n end\n end",
"def new\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render xml: @user }\n end\n end",
"def new\n @personal_info = PersonalInfo.new\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @personal_info }\n end\n end",
"def new\n @profile = Profile.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @profile }\n end\n end",
"def new\n @profile = Profile.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @profile }\n end\n end",
"def new\n @profile = Profile.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @profile }\n end\n end",
"def new\n \t@login = Login.new\n\t@account = Account.new( :language => 'English', :location_country => 'U.S.A.', :login => Login.new )\n\tto_show_login\t\t# makes the encryption keys\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n \t@account = Account.new\n end",
"def new\n @bank_deposit_account_type = BankDepositAccountType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @bank_deposit_account_type }\n end\n end",
"def new\n @company = Company.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company }\n end\n end",
"def new\n @profile = Profile.new \n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @profile }\n end\n end",
"def new\n head :status => 405\n return\n \n @participant = Participant.new\n\n respond_to do |format|\n format.html # new.html.erb\n #format.xml { render :xml => @participant }\n end\n end",
"def getnewaddress(account = nil)\n request :getnewaddress, account\n end",
"def create\n @account = Account.new(params[:account])\n\n respond_to do |format|\n if @account.save\n #format.html { redirect_to(@account, :notice => 'Account was successfully created.') }\n format.json { render :json => @account, :status => :created, :location => @account }\n format.xml { render :xml => @account, :status => :created, :location => @account }\n else\n #format.html { render :action => \"new\" }\n format.json { render :json => @account.errors, :status => :unprocessable_entity }\n format.xml { render :xml => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @user_addon = UserAddon.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user_addon }\n end\n end",
"def new\n @domain = Domain.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @domain }\n end\n end",
"def new\n @companyprofile = Companyprofile.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @companyprofile }\n end\n end",
"def new\n\tputs \"\\n\\t\\t in new\\n\"\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user }\n end\n end",
"def new\n @user = V1::User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user }\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @profile }\n end\n end",
"def new\n @repo = Repo.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @repo }\n end\n end",
"def new\n @company_profile = CompanyProfile.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @company_profile }\n end\n end",
"def new\n @node = Node.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @node }\n end\n end",
"def new\n @node = Node.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @node }\n end\n end",
"def create\n @account = Account.new(params[:account])\n @account.member = current_member\n logger.info @account.inspect\n \n respond_to do |format|\n if @account.save\n flash[:notice] = 'Thanks for signing up!' \n format.html { \n redirect_back_or_default('/')\n }\n format.xml do\n headers[\"Location\"] = account_url(@account)\n render :nothing => true, :status => \"201 Created\"\n end\n else\n flash[:notice] = 'There was a problem creating your account, but we can address that later. If you need to sell something right now, please contact support.'\n redirect_back_or_default('/')\n format.xml { render :xml => @account.errors.to_xml }\n end\n end\n end",
"def new\n @tr_account = TrAccount.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @tr_account }\n end\n end",
"def new\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user }\n end\n end",
"def new\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @user }\n end\n end",
"def new\n @account = Account.find(params[:account_id])\n @account_item = @account.account_items.build\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @account }\n end\n end",
"def new\n @usr = Usr.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @usr }\n end\n end"
] | [
"0.78234375",
"0.78234375",
"0.78234375",
"0.7822262",
"0.7814345",
"0.78114384",
"0.7665048",
"0.76641136",
"0.76237977",
"0.7428634",
"0.7207884",
"0.71446705",
"0.70970106",
"0.70845264",
"0.708054",
"0.708054",
"0.708054",
"0.708054",
"0.708054",
"0.7073275",
"0.701499",
"0.6978699",
"0.6970372",
"0.69682133",
"0.6878409",
"0.68546367",
"0.6850457",
"0.6773898",
"0.67731977",
"0.67393005",
"0.6736229",
"0.67151374",
"0.6711997",
"0.67015684",
"0.6683594",
"0.66611135",
"0.6653001",
"0.66394395",
"0.6633908",
"0.6620491",
"0.66097647",
"0.6603763",
"0.6592507",
"0.6592051",
"0.65806353",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.6577529",
"0.65716684",
"0.65700835",
"0.65658367",
"0.6560944",
"0.6560944",
"0.6560944",
"0.6560944",
"0.6560944",
"0.6560944",
"0.6560944",
"0.6560295",
"0.6559552",
"0.6559552",
"0.6558075",
"0.6556294",
"0.6535337",
"0.6530777",
"0.65295875",
"0.6528863",
"0.6528863",
"0.6528863",
"0.6528696",
"0.6524478",
"0.65209836",
"0.65142524",
"0.6513317",
"0.6507656",
"0.6507244",
"0.6506474",
"0.6500654",
"0.64979035",
"0.64934695",
"0.6487606",
"0.6486845",
"0.648056",
"0.6480476",
"0.6477108",
"0.6476422",
"0.6476422",
"0.6468408",
"0.64554894",
"0.64518034",
"0.64518034",
"0.6450427",
"0.64398724"
] | 0.7152347 | 11 |
This prints the board | def display_board(board)
puts " #{board[0]} | #{board[1]} | #{board[2]} "
puts "-----------"
puts " #{board[3]} | #{board[4]} | #{board[5]} "
puts "-----------"
puts " #{board[6]} | #{board[7]} | #{board[8]} "
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_board\n\t\tputs \"**********************************\"\n\t\tputs \"| ♔ ♚ ♕ ♛ ♖ ♜ ♗ ♝ ♘ ♞ ♙ ♟ |\"\n\t\tputs \"| Actual board |\"\n\t\tputs \"| ♔ ♚ ♕ ♛ ♖ ♜ ♗ ♝ ♘ ♞ ♙ ♟ |\"\n\t\tputs \"**********************************\"\n\t\[email protected]_index do |i|\n\t\t\t@board[i].each_index do |y|\n\t\t\t\tif y == 0\n\t\t\t\t\tprint 8 - i\n\t\t\t\tend\n\n\t\t\t\tif @board[i][y] == nil\n\t\t\t\t\tprint \"#{@board[i][y]} --\"\n\t\t\t\telse\n\t\t\t\t\tprint \" #{@board[i][y].piecename}\"\n\t\t\t\tend\n\n\t\t\tend\n\t\t\tputs \"\\n\"\n\t\tend\n\t\tputs \" a b c d e f g h\"\n\t\tputs \"\\n\\n\\n\\n\"\n\tend",
"def print_board\n puts \"\\n[#{@spaces[1]}][#{@spaces[2]}][#{@spaces[3]}]\\n[#{@spaces[4]}][#{@spaces[5]}][#{@spaces[6]}]\\n[#{@spaces[7]}][#{@spaces[8]}][#{@spaces[9]}]\\n\\n\"\n end",
"def print_board\n @board.each_slice(1) { |a| p a }\n puts\"\\n\"\n end",
"def print_board\n print to_s\n # @board.each do |row|\n # row.each do |square|\n # print \" #{square.number} \"\n # end\n # puts \"\"\n # end\n end",
"def print_board\n puts\n @board.each_with_index do |row, index|\n print \" \"\n row.each_with_index do |element, index|\n print \" \" + element.to_s.center(3, \" \") + \" \"\n if(index < row.length - 1)\n print \"|\"\n else\n print \"\\n\"\n end\n end\n\n if(index < @board.length - 1)\n print \" \"\n row.each_with_index do |element, index|\n print \"-----\"\n if(index < row.length - 1)\n print \"+\"\n else\n print \"\\n\"\n end\n end\n end\n end\n puts\n end",
"def print_board\n\n\t\[email protected]_with_index do |row, i|\n\n\t\t\trow.each do |space|\n\n\t\t\t\tprint \"|#{space}|\"\n\n\t\t\tend\n\n\t\t\tif i == 2\n\t\t\t\tputs \"\"\n\t\t\telse\n\t\t\t\tputs \"\"\n\t\t\t\tputs \"---------\"\n\t\t\tend\n\n\t\tend\n\n\tend",
"def print_board\n\t\tprint \"\\n\"\n\t\t(0..2).each do |row|\n\t\t\t(0..2).each do |column|\n\t\t\t\tprint @board[row][column]\n\t\t\t\tprint \" | \" unless column == 2\n\t\t\tend\n\t\t\t\n\t\t\tprint \"\\n---------\\n\" unless row == 2\n\t\tend\n\t\tprint \"\\n\\n\"\n\tend",
"def display_board\n\t board =\" | | \\n-----------\\n | | \\n-----------\\n | | \"\n\t puts board\n\tend",
"def print_board\n\t\tputs \"\"\n\t\tputs \" 1 2 3 4 5 6 7 8\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" A ||\"\n\t\tprint_row 0\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" B ||\"\n\t\tprint_row 1\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" C ||\"\n\t\tprint_row 2\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" D ||\"\n\t\tprint_row 3\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" E ||\"\n\t\tprint_row 4\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" F ||\"\n\t\tprint_row 5\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" G ||\"\n\t\tprint_row 6\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\"\n\t\tprint \" H ||\"\n\t\tprint_row 7\n\t\tputs \"|\"\n\t\tputs \" |-------------------------|\\n\\n \"\n\tend",
"def show_board\n puts\n @board.each_with_index do |square, i|\n print \" #{square} \"\n puts \"\\n\\n\" if (i == 2 || i == 5 || i == 8)\n end\n end",
"def display_board\n\t\tsystem \"clear\" or system \"cls\"\n\t\tprint \" 1 2 3 4 5 6 7 8 \\n\\n\"\n\t\t(0..7).each do |row|\n\t\t\tprint \"#{(row+97).chr} \"\n\t\t\t(0..7).each do |collumn|\n\t\t\t\tprint \"#{@board[row][collumn]} \" if @board[row][collumn] == \"X\"\n\t\t\t\tprint @board[row][collumn].to_s + \" \" if @board[row][collumn].is_a?(Piece)\n\t\t\tend\n\t\t\tprint \" #{(row+97).chr} \"\n\t\t\tputs\n\n\t\tend\n\t\tprint \"\\n 1 2 3 4 5 6 7 8 \\n\"\n\tend",
"def print_board\n\t\tputs \"GAME BOARD AT TIME: #{@current_turn}\"\n\t\tprint full_game_board.map{|c| c.join(\"\")}.join(\"\\n\")\n\tend",
"def print_board\r\n\t\t@board_array.each do |char|\r\n\t\t\tprint \"#{char} \"\r\n\t\tend\r\n\t\tputs \"\"\r\n\t\t@board_array\r\n\tend",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def print_board(board)\n # See http://cl.ly/image/3t450Y271d25 for expected output\n\n\tfor i in 0..board.rows-1\n\t\tprint '|'\n\t\tfor j in 0..board.columns-1\n\t\t\tprint board.at(i,j)\n\t\t\tprint '|'\n\t\tend\n\t\tputs \"\\n\"\n\tend \nend",
"def print_board\n 6.times do |y|\n y = 5 - y # To print from top to bottom\n 7.times do |x|\n if @board[[x, y]] == nil\n x == 6 ? (puts \"( )\") : (print \"( )\")\n else\n # Prints only the 3 first letters of each color to keep board alignment\n x == 6 ? (puts \"(#{@board[[x, y]].color[0, 3]})\") : (print \"(#{@board[[x, y]].color[0, 3]})\")\n end\n end\n end\n end",
"def board\n @board.each do |row|\n print row\n puts \"\"\n end\n end",
"def print_board\n if @board.nil?\n puts \"Board not initialized\"\n elsif @board.respond_to?(\"each\")\n @board.each do |row|\n row.each do |cell|\n print \"#{cell} \"\n end\n puts \"\\n\"\n end\n end\n puts \"\\n\"\n end",
"def print_board(board)\n p \"--------------------------------------------------------------------------------------------------------------\"\n count = 0\n puts \" | 0 1 2 3 4 5\"\n # puts \"___________________\"\n board.each do |line|\n print \"#{count}|\"\n line.each do |x|\n if x.nil?\n print ' 0 '.colorize(:blue)\n else\n print \" #{x.color[0]} \".colorize(:yellow) if x.color == 'white'\n print \" #{x.color[0]} \".colorize(:red) if x.color == 'black'\n end\n end\n print \"|#{count}\"\n count += 1\n puts \"\"\n\n end\n puts \" | 0 1 2 3 4 5\"\n p \"--------------------------------------------------------------------------------------------------------------\"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \" ----------- \"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \" ----------- \"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"---------------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"---------------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board()\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board()\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def print\n displayBoard = []\n @board.each_with_index { |elem, index|\n if index % @columns == 0\n displayBoard.push(\"\\n\")\n end\n displayBoard.push(elem)\n }\n puts displayBoard.join\n end",
"def print_board(board)\n puts \"PRINTING BOARD- START\\n\\n\"\n\n if (board == false)\n #\tputs \"INVALID SUDOKU BOARD... check input\"\n\t return\n end\n\n for x in 0..board.length-1\n \t\tfor y in 0..board.length-1\n print board[x][y] , \" | \"\n end\n puts\n end\n puts \"\\n\\nPRINTING BOARD END\"\n end",
"def show_board\n puts \" \" + board_spaces[1] + \" | \" + board_spaces[2] + \" | \" + board_spaces[3] + \" \"\n puts \"-----------\"\n puts \" \" + board_spaces[4] + \" | \" + board_spaces[5] + \" | \" + board_spaces[6] + \" \"\n puts \"-----------\"\n puts \" \" + board_spaces[7] + \" | \" + board_spaces[8] + \" | \" + board_spaces[9] + \" \"\n end",
"def display_board\n\t\tputs \"\\n\\n\"\n\t\tprint \"|\\u2460 |\\u2461 |\\u2462 |\\u2463 |\\u2464 |\\u2465 |\\u2466 |\"\n\t\[email protected] do |row|\n\t\t\tprint \"\\n|\"\n\t\t\trow.each {|x| print \"#{x.to_c} |\"} \t\t\t\n\t\tend\n\t\tputs \"\"\n\tend",
"def print_board(board = @board)\n\t\tputs '. a b c d e f g h'\n\t\tboard.each_with_index do |row, ri|\n\t\t\tprint \"#{ri + 1} \"\n\t\t\trow.each_with_index do |col, ci|\n\t\t\t\t(col.nil? ? (ri.even? ? (ci.even? ? whitesq : blacksq) : (ci.even? ? blacksq : whitesq)) : (print col))\n\t\t\t\tprint ' '\n\t\t\tend\n\t\t\tputs\n\t\tend\n\n\t\tprint_taken_pieces\n\t\tputs\n\n\tend",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n\n puts \" #{@board[0].mark} | #{@board[1].mark} | #{@board[2].mark} \"\n puts \"-----------\"\n puts \" #{@board[3].mark} | #{@board[4].mark} | #{@board[5].mark} \"\n puts \"-----------\"\n puts \" #{@board[6].mark} | #{@board[7].mark} | #{@board[8].mark} \"\n end",
"def printBoard\n\t\tprint(\"#{@field[0].value} | #{@field[1].value} | #{@field[2].value}\\n---------\\n#{@field[3].value} | #{@field[4].value} | #{@field[5].value}\\n---------\\n#{@field[6].value} | #{@field[7].value} | #{@field[8].value}\")\n\tend",
"def display_board(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \"\n puts \"---+----+----\"\n puts \" #{board[3]} | #{board[4]} | #{board[5]} \"\n puts \"---+----+----\"\n puts \" #{board[6]} | #{board[7]} | #{board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts '---------------'\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts '---------------'\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \"\n puts \"-----------\"\n puts \" #{board[3]} | #{board[4]} | #{board[5]} \"\n puts \"-----------\"\n puts \" #{board[6]} | #{board[7]} | #{board[8]} \"\n end",
"def display_board(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \"\n puts \"-----------\"\n puts \" #{board[3]} | #{board[4]} | #{board[5]} \"\n puts \"-----------\"\n puts \" #{board[6]} | #{board[7]} | #{board[8]} \"\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \" ----------- \"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \" ----------- \"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n\n end",
"def printBoard(board)\n\tputs \"#{board[7]} | #{board[8]} | #{board[9]}\"\n\tputs \"--+---+--\"\n\tputs \"#{board[4]} | #{board[5]} | #{board[6]}\"\n\tputs \"--+---+--\"\n\tputs \"#{board[1]} | #{board[2]} | #{board[3]}\"\nend",
"def display_board\r\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\r\n puts \"-----------\"\r\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\r\n puts \"-----------\"\r\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\r\n end",
"def display_board\r\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\r\n puts \"-----------\"\r\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\r\n puts \"-----------\"\r\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\r\n end",
"def display_board\n puts \" \" + (\"_\" * 47)\n 8.downto(1) do |l|\n puts \" \" +(\"| \" * 8 ) + \"|\"\n puts \" #{l} | \" + @board[l-1].join(\" | \") + \" |\"\n puts \" \" +(\"|_____\" * 8 ) + \"|\"\n end\n puts (\" \" * 8) + ('a'..'h').to_a.join(\" \")\n end",
"def display_board\n display = \" a b c d e f g h \\n\"\n @board.each_with_index do |arr, i|\n line = \"#{i + 1} \"\n arr.each do |hash|\n hash[:piece].nil? ? line += \"#{hash[:base]} \" : line += \"#{hash[:piece].name} \"\n end\n line += \"\\n\"\n display += line\n end\n display\n end",
"def print_board(board)\n puts\n for y in (0...9)\n for x in (0...9) \n print board[y][x][0]\n end\n puts\n end\n puts\n return\n end",
"def display\n @board.each { |x| \n puts x.join(\" \")\n }\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \" \n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def display_board\n puts \"#{@board[0].value} | #{@board[1].value} | #{@board[2].value}\"\n puts \"-\"*10\n puts \"#{@board[3].value} | #{@board[4].value} | #{@board[5].value}\"\n puts \"-\"*10\n puts \"#{@board[6].value} | #{@board[7].value} | #{@board[8].value}\"\n end",
"def display_board\n puts\n puts \"Here is the current board:\"\n puts \n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"---+---+---\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"---+---+---\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n puts \n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n\n end",
"def display_board\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n end",
"def print_board\n col_numbers = [' ']\n (1..8).each do |row|\n row_items = []\n\n col_numbers << ' ' + row.to_s + ' '\n row_items << row\n \n (1..8).each do |col|\n row_items << @board[[row,col]].console_rep\n end\n\n puts row_items.join(' ')\n end\n puts col_numbers.join(' ')\n end",
"def print_board\n \tputs '___________________________________________'\n puts @count == @board.length**2 ? 'Knight Tour Completed' : 'Incomplete'\\\n ' tour of Knight'\n puts '___________________________________________'\n @path.length.times do |row|\n @path.length.times do |col|\n print \"\\s #{@path[row][col]} \\s\"\n end\n puts\n end\n puts '___________________________________________'\n end",
"def display_board\n\n puts \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n puts \"-----------\"\n puts \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n puts \"-----------\"\n puts \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\n\n end",
"def display_board\n puts \" \" \"|\" \" \" \"|\" \" \"\n puts \"-----------\"\n puts \" \" \"|\" \" \" \"|\" \" \"\n puts \"-----------\"\n puts \" \" \"|\" \" \" \"|\" \" \"\nend",
"def show_board(board)\n\n puts \"\n #{board[0]} | #{board[1]} | #{board[2]}\n #{board[3]} | #{board[4]} | #{board[5]}\n #{board[6]} | #{board[7]} | #{board[8]}\n \"\nend",
"def print_boards\n\t\tputs \" SHIP STATUS SHOTS TAKEN\".colorize(:light_red)\n\t\tputs \" 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10\".colorize(:green)\n\t\trow_letter = ('A'..'Z').to_a\n\t\trow_number = 0\n\t\[email protected] do |row1|\n\t\t\tprint row_letter[row_number].colorize(:green) + ' '\n\t\t\tprint_cell(row1)\n\t\t\tprint \" \"\n\t\t\tprint row_letter[row_number].colorize(:green) + ' '\n\t\t\tprint_row_number(row_number)\n\t\t\tprint \"\\n\"\n\t\t\trow_number += 1\n\t\tend\n\tend",
"def print_boards\n puts \" SHIP STATUS SHOTS TAKEN\".colorize(:white)\n puts \" 1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10\".colorize(:white)\n row_letter = ('A'..'Z').to_a\n row_number = 0\n @board.grid.each do |row1|\n print row_letter[row_number].colorize(:white) + ' '\n row1.each {|cell| print cell.to_s + ' '}\n print \" \"\n print row_letter[row_number].colorize(:white) + ' '\n @target_board.grid[row_number].each {|cell| print cell.to_s + ' '}\n print \"\\n\"\n row_number += 1\n end\n end",
"def display_board(board)\n separator = \"|\"\n lines = \"-----------\"\n \n puts \" #{board[0]} #{separator} #{board[1]} #{separator} #{board[2]} \"\n puts \"#{lines}\"\n puts \" #{board[3]} #{separator} #{board[4]} #{separator} #{board[5]} \"\n puts \"#{lines}\"\n puts \" #{board[6]} #{separator} #{board[7]} #{separator} #{board[8]} \"\nend",
"def PrintBoard(board)\n #Display board in same format as instuctions, with values filled in\n for i in 0..8\n print \"|\" + board[i]\n if i % 3 == 2\n #Start new line every 3 columns\n print \"|\\n\"\n end\n end\n end",
"def show_board\n \[email protected] do |y|\n \t\tputs ' '\n \t\[email protected] do |x|\n \t\t\tprint \"#{@board[y][x]} \"\n \t\tend\n \tend \n \tputs ' '\n end",
"def game_board_display(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \"\n puts \"-----------\"\n puts \" #{board[3]} | #{board[4]} | #{board[5]} \"\n puts \"-----------\"\n puts \" #{board[6]} | #{board[7]} | #{board[8]} \"\n\n end",
"def display\n puts \"#{@board.join(\" \")}\"\n end",
"def print_board\n for num in 0..4 do\n print \" \" + @top_row[num].to_s + \" \"\n end\n puts \"\"\n for num in 0..4 do\n puts \"#{@left_column[num].to_s} #{@board[num]}\"\n end\nend",
"def show_board\n @display.each do |row|\n puts row.join(' ')\n end\n end",
"def print_board\r\n @squares.each do | i |\r\n print \" \"\r\n puts \"-\" * 33\r\n i.each do | val |\r\n print \" | \"\r\n print val\r\n end\r\n puts \" |\"\r\n end\r\n print \" \"\r\n puts \"-\" * 33\r\n puts \"\\n\"\r\n end",
"def display_board\n puts \" | | \"\n puts\"-----------\"\n puts \" | | \"\n puts\"-----------\"\n puts \" | | \"\nend",
"def display_board(board)\n\tputs \" #{board[0]} | #{board[1]} | #{board[2]} \"\n\tputs \"-----------\"\n\tputs \" #{board[3]} | #{board[4]} | #{board[5]} \"\n\tputs \"-----------\"\n\tputs \" #{board[6]} | #{board[7]} | #{board[8]} \"\nend",
"def display_board(board)\n colors=board\n r=\"-----------\"\n puts \" #{colors[0]} | #{colors[1]} | #{colors[2]} \"\n puts r\n puts \" #{colors[3]} | #{colors[4]} | #{colors[5]} \"\n puts r\n puts \" #{colors[6]} | #{colors[7]} | #{colors[8]} \"\nend",
"def display_board(board)\n puts \" #{board[0]} \" \"|\" \" #{board[1]} \" \"|\" \" #{board[2]} \"\n puts \"-----------\"\n puts \" #{board[3]} \" \"|\" \" #{board[4]} \" \"|\" \" #{board[5]} \"\n puts \"-----------\"\n puts \" #{board[6]} \" \"|\" \" #{board[7]} \" \"|\" \" #{board[8]} \"\nend",
"def display_board\n\t\t\tsystem(\"cls\")\n\t\t\tprint \"\\n\"\n\t\t\t 7.downto(0).each_with_index{|x|\n\t\t\t\t print \"#{x+1}| \"\n\t\t\t\t\t8.times{|y|\n\t\t\t\t\tif y%2==0 && x%2 == 0 || y%2==1 && x%2 == 1\n\t\t\t\t\t\tif @board[y][x] != nil && @board[y][x].color == \"white\"\n\t\t\t\t\t\t\tprint @board[y][x].class.to_s[0].white.bold.on_red, \" \".on_red\n\t\t\t\t\t\telsif @board[y][x] != nil && @board[y][x].color == \"black\"\n\t\t\t\t\t\t\tprint @board[y][x].class.to_s[0].green.bold.on_red, \" \".on_red\n\t\t\t\t\t\telse \n\t\t\t\t\t\t\tprint \" \".on_red\n\t\t\t\t\t\tend\n\t\t\t\t\telse\n\t\t\t\t\t\tif @board[y][x] != nil && @board[y][x].color == \"white\"\n\t\t\t\t\t\t\tprint @board[y][x].class.to_s[0].white.bold, \" \"\n\t\t\t\t\t\telsif @board[y][x] != nil && @board[y][x].color == \"black\"\n\t\t\t\t\t\t\tprint @board[y][x].class.to_s[0].green.bold, \" \"\n\t\t\t\t\t\telse \n\t\t\t\t\t\t\tprint \" \", \" \"\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\t\t}\n\t\t\t\tprint \"\\n\"\n\t\t\t\t }\n\t\t\t print \"------------------\\n\"\n\t\t\t print \" a b c d e f g h\\n\\n\"\n\tend",
"def display_board\n puts \" | | \"\n puts \"-----------\"\n puts \" | | \"\n puts \"-----------\"\n puts \" | | \"\nend",
"def display_board\n puts \" | | \"\n puts \"-----------\"\n puts \" | | \"\n puts \"-----------\"\n puts \" | | \"\nend",
"def display_board\r\nprint \" #{@board[0]} | #{@board[1]} | #{@board[2]} \\n\"\r\nprint \"-----------\\n\"\r\nprint \" #{@board[3]} | #{@board[4]} | #{@board[5]} \\n\"\r\nprint \"-----------\\n\"\r\nprint \" #{@board[6]} | #{@board[7]} | #{@board[8]} \"\r\nend",
"def display_board(board)\n cell1 = \" #{board[0]} \"\n cell2 = \" #{board[1]} \"\n cell3 = \" #{board[2]} \"\n cell4 = \" #{board[3]} \"\n cell5 = \" #{board[4]} \"\n cell6 = \" #{board[5]} \"\n cell7 = \" #{board[6]} \"\n cell8 = \" #{board[7]} \"\n cell9 = \" #{board[8]} \"\n box = \"|\"\n line = \"-----------\"\n print cell1, box, cell2, box, cell3\n print \"\\n\",line\n print \"\\n\",cell4, box, cell5, box, cell6\n print \"\\n\",line\n print \"\\n\",cell7, box, cell8, box, cell9, \"\\n\"\nend",
"def display_board(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \"\n puts \"-----------\\n\"\n puts \" #{board[3]} | #{board[4]} | #{board[5]} \"\n puts \"-----------\\n\"\n puts \" #{board[6]} | #{board[7]} | #{board[8]} \"\nend",
"def display_board\n print \" #{@board[0]} | #{@board[1]} | #{@board[2]} \"\n print \"-----------\"\n print \" #{@board[3]} | #{@board[4]} | #{@board[5]} \"\n print \"-----------\"\n print \" #{@board[6]} | #{@board[7]} | #{@board[8]} \" \nend",
"def print_board\n\t\tcell_index=1\n\t\tputs \"\\n\\n\\t[A]\\t[B]\\t[C]\"\n\t\t@cell_status.each_key do |cell|\n\t\t\tcase cell\n\t\t\twhen \"A1\" \n\t\t\t\tprint \" [1]\\t #{marker_on_cell(cell)}\"\n\t\t\twhen \"B1\" \n\t\t\t\tprint \" | #{marker_on_cell(cell)}\"\n\t\t\twhen \"C1\" \n\t\t\t\tprint \" |\\t#{marker_on_cell(cell)}\\n\"\n\t\t\t\tputs \"\\t--------------------\"\n\t\t\twhen \"A2\" \n\t\t\t\tprint \" [2]\\t #{marker_on_cell(cell)}\"\n\t\t\twhen \"B2\" \n\t\t\t\tprint \" | #{marker_on_cell(cell)}\"\n\t\t\twhen \"C2\" \n\t\t\t\tprint \" |\\t#{marker_on_cell(cell)}\\n\"\n\t\t\t\tputs \"\\t--------------------\"\n\t\t\twhen \"A3\" \n\t\t\t\tprint \" [3]\\t #{marker_on_cell(cell)}\"\n\t\t\twhen \"B3\" \n\t\t\t\tprint \" | #{marker_on_cell(cell)}\"\n\t\t\twhen \"C3\" \n\t\t\t\tprint \" |\\t#{marker_on_cell(cell)}\\n\"\n\t\t\tend\t\n\t\tend\n\tend",
"def display_board\n puts \" | | \" \n puts \"-----------\"\n puts \" | | \"\n puts \"-----------\"\n puts \" | | \"\nend",
"def display_board\n puts \" #{@letter[0]} | #{@letter[1]} | #{@letter[2]} \"\n puts \" -------------\"\n puts \" #{@number[0]}| #{@board_array[0]} | #{@board_array[1]} | #{@board_array[2]} |\"\n puts \" |-----------|\"\n puts \" #{@number[1]}| #{@board_array[3]} | #{@board_array[4]} | #{@board_array[5]} |\"\n puts \" |-----------|\"\n puts \" #{@number[2]}| #{@board_array[6]} | #{@board_array[7]} | #{@board_array[8]} |\"\n puts \" ------------\"\n end",
"def printBoard\n\tkey = 0\n\tfor i in 1..9\n\t\tprint \"[ #{@bo[i-1]} ]\"\n\t\tif i % 3 == 0 then \n\t\t\tprint \" \"\n\t\t\t0.upto(2) do\n\t\t\t\tprint \"[ #{key} ]\"\n\t\t\t\tkey = key + 1\n\t\t\tend\n\t\t\tprint \"\\n\"\n\t\tend\n\tend\n end",
"def display_board(board)\n puts \" #{board[0] } | #{board[1]} | #{board[2]} \"\n puts \"-----------\"\n puts \" #{board[3] } | #{board[4]} | #{board[5]} \"\n puts \"-----------\"\n puts \" #{board[6] } | #{board[7]} | #{board[8]} \"\nend",
"def display_board(board)\n puts \" #{board[0]} | #{board[1]} | #{board[2]} \\n-----------\\n #{board[3]} | #{board[4]} | #{board[5]} \\n-----------\\n #{board[6]} | #{board[7]} | #{board[8]} \"\nend",
"def print_board\n reputs('|')\n clear_screen!\n move_to_home!\n @players.each_with_index do |value,index|\n p board[index]\n puts\n end\n\n end",
"def drawBoard\n @board.each do |element|\n print \"#{element} \"\n puts \"\"\n end\n end",
"def display_board(brd)\n puts \"\"\n puts \" | |\"\n puts \" #{brd[1]} | #{brd[2]} | #{brd[3]}\"\n puts \" | |\"\n puts \"-----+-----+-----\"\n puts \" | |\"\n puts \" #{brd[4]} | #{brd[5]} | #{brd[6]}\"\n puts \" | |\"\n puts \"-----+-----+-----\"\n puts \" | |\"\n puts \" #{brd[7]} | #{brd[8]} | #{brd[9]}\"\n puts \" | |\"\n puts \"\"\nend",
"def display_board\n str = \"\"\n 5.downto(0) do |i|\n @board.each {|row| str += row[i].to_s + \" \"}\n str += \"\\n\"\n end\n puts str\n end",
"def display_board(board)\n puts \" #{board[0]}|#{board[1]}|#{board[2]}\"\n puts \"___________\"\n puts \"#{board[3]}|#{board[4]}|#{board[5]}\"\n puts \"___________\"\n puts \" #{board[6]}|#{board[7]}|#{board[8]}\"\nend"
] | [
"0.912189",
"0.88865775",
"0.8880699",
"0.8822096",
"0.8814379",
"0.87795323",
"0.8720118",
"0.87068605",
"0.87050074",
"0.86798745",
"0.8672375",
"0.86657983",
"0.8656733",
"0.8652426",
"0.86493194",
"0.8633315",
"0.86251116",
"0.8625003",
"0.86223125",
"0.8611828",
"0.8609417",
"0.86017966",
"0.86017966",
"0.85983896",
"0.85910577",
"0.85897154",
"0.8579663",
"0.85756207",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.8572811",
"0.85695606",
"0.85666835",
"0.85644674",
"0.85537475",
"0.8543536",
"0.8528132",
"0.8528132",
"0.85261893",
"0.8525614",
"0.852201",
"0.85139847",
"0.85139847",
"0.8507004",
"0.85068125",
"0.85065085",
"0.84979963",
"0.8487309",
"0.84820235",
"0.84791285",
"0.8473211",
"0.84683317",
"0.8466378",
"0.8463845",
"0.84543735",
"0.8450589",
"0.8447598",
"0.84446156",
"0.8435519",
"0.84278667",
"0.8418248",
"0.8412522",
"0.84112865",
"0.84093595",
"0.8403548",
"0.84008217",
"0.83942753",
"0.83855224",
"0.83753407",
"0.8366956",
"0.83625215",
"0.8359543",
"0.83495605",
"0.83495605",
"0.83466274",
"0.8335894",
"0.8328158",
"0.8324778",
"0.83247155",
"0.832468",
"0.83228934",
"0.8319376",
"0.8318743",
"0.8312179",
"0.831032",
"0.83064663",
"0.8302678",
"0.8299657",
"0.8297503"
] | 0.0 | -1 |
Checks if position is already taken | def position_taken?(board, position)
!(board[position] == "" || board[position] == " " || board[position] == nil)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position_taken?(index)\n @board[index] == \"X\" || @board[index] == \"O\"\n end",
"def position_taken?\nend",
"def position_taken?(index)\n ((@board[index] == \"X\") || (@board[index] == \"O\"))\n end",
"def position_taken?(position)\n @board[position] != \" \"\n end",
"def position_taken?(position)\n @board[position] != nil && @board[position] != \" \"\n end",
"def position_taken?(position)\n @board[position] != \" \"\n end",
"def position_taken?(board, position)\n\tif board[position] == \"X\" || board[position] == \"0\"\n\t\treturn true\n\telse\n\t\treturn false\n\tend\nend",
"def position_taken?(board, pos)\n if board[pos]==\"X\" || board[pos]==\"O\"\n taken = true\n else\n taken = false\n end\n taken\nend",
"def position_taken?(location)\n @board[location] != \" \" && @board[location] != \"\"\n end",
"def position_taken?(location)\n @board[location] != \" \" && @board[location] != \"\"\n end",
"def position_taken?(index)\n @board[index]==\"X\" || @board[index] == \"O\"\nend",
"def position_taken?(board, position)\n return false if valid_move?(board, position)\n return true unless valid_move?(board, position)\nend",
"def position_taken?(index)\n if @board[index] == nil or @board[index] == \"\" or @board[index] == \" \"\n return false\n elsif @board[index] == \"X\" or @board[index] == \"O\"\n return true\n end\n end",
"def position_taken?(position)\r\n if @board[position] == \"\" || @board[position] == \" \" || @board[position] == nil\r\n return false\r\n elsif @board[position] == \"X\" || @board[position] == \"O\"\r\n return true\r\n end\r\n end",
"def position_taken?(position)\n if @board[position] == \" \" || @board[position] == \"\" || @board[position] == nil\n false\n elsif @board[position] == \"X\" || @board[position] == \"O\"\n true\n end\n end",
"def position_taken?(location)\n @board[location] != \" \" && @board[location] != \"\"\n end",
"def position_taken?(position)\n !(@board[position].nil? || @board[position] == \" \")\n end",
"def position_taken?(index_i)\n ((@board[index_i] == \"X\") || (@board[index_i] == \"O\"))\n end",
"def position_taken?(index_i)\n ((@board[index_i] == \"X\") || (@board[index_i] == \"O\"))\n end",
"def position_taken?(board, index)\n board[index] == \"X\" || board[index] == \"O\"\n end",
"def position_taken?(index)\n if @board[index] == \"X\"\n true\n elsif @board[index] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(index)\n\t\t!@board[index].include?(\" \")\n\tend",
"def position_taken?(board, index)\n space = board[index]\n if space == 'X' || space == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(index)\n @board[index] != \" \" && @board[index] != \"\"\n end",
"def position_taken?(board, position)\n return true if board[position - 1] == \"X\" || board[position - 1] == \"O\"\n false\nend",
"def position_taken?(index)\n if @board[index] == \" \" || @board[index] == \"\" || @board[index] == nil\n return false\n elsif @board[index] == \"X\" || @board[index] == \"O\"\n return true\n end\n end",
"def position_taken?(index)\n ! ( @board[index].nil? || @board[index] == \" \" )\n end",
"def position_taken?(board, position)\n position = position.to_i - 1\n if board[position] == \"X\" || board[position] == \"O\"\n true\n end\nend",
"def position_taken?(board,pos)\n if board[pos.to_i]==\"X\" || board[pos.to_i] ==\"O\"\n return true\n else\n return false\n end\nend",
"def position_taken? (index)\n @board[index] != \" \" ? true : false\n end",
"def position_taken?(board,position)\n position = position.to_i - 1\n if board[position] == \"X\" || board[position] == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(board, position)\n if !(board[position.to_i - 1] == \"X\" || board[position.to_i - 1] == \"O\")\n return true\n else \n return false\n end\nend",
"def position_taken?(board,position)\n return true if board[position]==\"X\" || board[position]==\"O\"\n return false\nend",
"def position_taken?(board, new_index)\n if board[new_index] == \"X\" || board[new_index] == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(board, position)\n if board[position] == \"X\" || board[position] == \"O\"\n return true\n end\n false\nend",
"def position_taken?(board, idx)\n\tif board[idx] == nil || board[idx] == \"\" || board[idx] == \" \" \n\t\tfalse\n\telsif board[idx] == \"X\" || board[idx] == \"O\"\n\t\ttrue\n\telse\n\t\tfalse\n\tend\nend",
"def position_taken?(board,position)\n pos = position.to_i\n val = board[pos-1]\n if val == \"X\" || val ==\"O\"\n true\n else\n false\n end\nend",
"def position_taken? index_position \n board[index_position] != \" \"\n end",
"def position_taken?(index)\n position = @board[index]\n \n if !(position.nil? || position.eql?(\" \") || position.empty?)\n return (position.eql?(\"X\") || position.eql?(\"O\"))\n else\n return false\n end\n end",
"def taken?(input)\n\t\tif position(input) == \"X\" || position(input) == \"O\"\n\t\t\ttrue # Position is taken\n\t\telse\n\t\t\tfalse # Position is free\n\t\tend\n\tend",
"def position_taken?(board, index_to_validate)\n if (board[index_to_validate] == \"X\" || board[index_to_validate] == \"O\")\n return true\n end\n return false # NOTE: if we arrive here, the position is definitely not taken\nend",
"def position_taken?(position)\n if @board[position] == \" \" || @board[position] == \"\" || @board[position] == nil\n false\n else\n true\n end\n end",
"def position_taken?( index )\n !(@board[index].nil? || @board[index] == \" \")\n end",
"def position_taken?(board, position)\n board[position] == 'X' || board[position] == 'O'\nend",
"def position_taken?(index)\n !(@board[index].nil? || @board[index] == \" \")\n end",
"def position_taken?(index)\n !(@board[index].nil? || @board[index] == \" \")\n end",
"def position_taken?(board, position)\n if board[position] == \"X\" || board[position] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(board, position)\n if (board[position] == \"X\" || board[position] == \"O\")\n true\n end\nend",
"def position_taken?(board, idx)\n [\"X\", \"O\"].include?(board[idx])\nend",
"def position_taken?(board,index)\n #This method must take in both the existing board and the index that the user\n #is trying to fill if the index is already occupied it will not allow this\n position_value=board[index]\n if position_value != nil\n if position_value.include? \"x\" or position_value.include? \"o\" or position_value.include? \"X\" or position_value.include? \"O\"\n return true\n else\n return false\n end\n else\n return false\n end\nend",
"def position_taken?(board, index)\n board[index] === \"X\" || board[index] ===\"O\" ? true : false\nend",
"def position_taken?(board, index)\n board[index] === \"X\" || board[index] ===\"O\" ? true : false\nend",
"def position_taken?(board, position)\n if !board.empty? && board[position] && (board[position].include?(\"X\") || board[position].include?(\"O\"))\n true\n else\n false\n end\nend",
"def position_taken?(index)\n !(@board[index].nil? || @board[index] == \" \")\n end",
"def position_taken?(board, position)\n if board[position] == \"X\" || board[position] == \"O\"\n return true\n end\nend",
"def position_taken?(board, position)\n p_taken = false\n if (board[position] == \"\" || board[position] == \" \" || board[position] == nil)\n p_taken = false\n else\n p_taken = true\n end\n p_taken\nend",
"def position_taken?(board, position)\n\tx = board[position -1]\n\tcase x \n\twhen \"\", \" \"\n\t\t return false \n\telse\n\t\t return true \n\tend\nend",
"def position_taken?(board, position)\n board[position] == \"X\" || board[position] == \"O\"\nend",
"def position_taken?(board, position)\n board[position] == \"X\" || board[position] == \"O\"\nend",
"def position_taken?(board, index)\n board[index]== \"X\" || board[index] == \"O\"\nend",
"def valid_move?(position)\r\n @index = position.to_i-1\r\n if @index.between?(0,8) && !position_taken?(@index)\r\n return true\r\n else\r\n return false\r\n end\r\n end",
"def position_taken?(board, index)\n if board[index] == \"X\" || board[index] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(board, index)\n if board[index] == \"X\" || board[index] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(board, index)\n if board[index] == \"X\" || board[index] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(board, idx)\n len = board.length\n if len == 0\n return false\n end\n \n out = board[idx]\n \n if out == nil\n return false \n end\n \n out_strip = out.strip\n if out_strip == \"X\" || out_strip == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(board, location)\n board[location] != \" \" && board[location] != \"\"\n end",
"def not_in_place?\r\n @position.nil?\r\n end",
"def position_taken?(input)\n @board[input] == \"X\" || @board[input] == \"O\"\n end",
"def position_taken?(board,index)\n if board[index] == \"X\" || board[index] == \"O\"\n TRUE\n else\n FALSE\n end\nend",
"def position_taken?(board, position)\n\tif board[position] == \" \" || board[position] == \"\" || board[position] == nil \n\t\treturn true\n\telse board[position] == \"O\" || \"X\"\n\t\treturn false\n\tend\nend",
"def position_taken?(board, position)\n\tif board[position] == \" \" || board[position] == \"\" || board[position] == nil \n\t\treturn true\n\telse board[position] == \"O\" || \"X\"\n\t\treturn false\n\tend\nend",
"def position_taken?(board, position)\n if ((board[position] == \"X\") || (board[position] == \"O\" ))\n return true\n elsif board[position] == nil\n false\n else\n false\n end\nend",
"def position_taken? (board,index)\n if ( board[index] == \"X\" || board[index] == \"O\" )\n return true\n else\n return false\n end\nend",
"def position_taken?(board, position)\n value = position.to_i - 1\n if board[value] == \"X\" || board[value] == \"0\"\n true\n end\nend",
"def position_taken?(board, index)\n if board[index] == \"X\" || board[index] == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(board, index)\n if board[index] == \"X\" || board[index] == \"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(pos)\r\n #true if space is empty and false if filled\r\n if @board[pos] == \" \"\r\n return false\r\n else\r\n return true\r\n end\r\n end",
"def crash?\n @position.length != @position.uniq.length\n end",
"def position_taken?(board, position)\n if (board[position] == \"X\" || board[position] == \"O\")\n true\n else\n false\n end\n\nend",
"def position_taken?(index)\n # If the board's index is nil or empty, will return a \"truthy\" value.\n !(@board[index].nil? || @board[index] == \" \")\n end",
"def position_taken?(index)\n if (@board[index] == \" \")\n return false\n else\n return true\n end\n end",
"def position_taken?(board, position)\n\ta = board[position.to_i - 1]\n\tif a != \" \"\n\t\treturn true\n\telse\n\t\treturn false\n\tend\nend",
"def position_taken?(board, index)\n board[index] == \"X\" || board[index] == \"O\"\nend",
"def position_taken?(board, position_index)\n board[position_index] == \"X\" or board[position_index] == \"O\"\nend",
"def position_taken?(position)\n !(@board[position.to_i] == \" \") \n end",
"def position_taken?(board, index)\n if board[index] == \"X\"\n true\n elsif board[index] == \"O\"\n true\n else\n false\n end\nend",
"def position_taken?(board, position)\n if board[position]==\"\" || board[position]==\" \"\n return false\n elsif board[position] == \"X\" || board[position]==\"O\"\n return true\n else\n return false\n end\nend",
"def position_taken?(move_index)\r\n if @board[move_index] == \" \"\r\n false\r\n else\r\n true\r\n end\r\n end",
"def position_taken?(board, position)\n if board[(position.to_i) - 1] == \" \" || board[(position.to_i) - 1] == \"\" || board[(position.to_i) - 1] == nil\n false\n elsif board[(position.to_i) - 1] == \"X\" || board[(position.to_i) - 1] == \"O\"\n \tfalse\n end\nend",
"def position_taken?(board, index_number)\n if board[index_number] == \" \" || board[index_number] == \"\" || board[index_number] == nil\n false\n else board[index_number] == \"X\" || board[index_number] == \"O\"\n end\n end",
"def position_taken?(board,index)\n # get index, check if index is taken\n # check board, false = not taken, true = taken\n #board = [\" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \"]\n board[index] == \" \" || \"\" || nil\n (board[index] == \"X\") || (board[index] == \"O\")\nend",
"def move_is_valid?(position)\n\t\tif @played_positions.index(position)\n\t\t\tresult = false\n\t\telse \n\t\t\t@played_positions << position \n\t\t\tresult = true\n\t\tend\n\t\tresult\n\tend",
"def valid_move?(position)\n index=position.to_i - 1\n index.between?(0, 8) && !(position_taken?(index))\n end",
"def position_taken?(board, position)\n return true if (board[position-1] == \" \" || board[position-1] == \"\" || board[position-1] == nil)\n return false if (board[position-1] == \"X\" || board[position-1] == \"O\")\nend",
"def position_taken?(board, position)\n\tif (board[position] == \" \" || board[position] == \"\" || board[position] == nil) \n\t\treturn false\n\telse\n\t\treturn true\n\tend\nend",
"def position_taken?(board, index) \n\tboard[index] != \" \"\nend",
"def position_taken?(board, location)\n\t!(board[location].nil? || board[location] == \" \")\nend",
"def position_taken?(board,index)\n [\"X\", \"O\"].include?(board[index])\nend",
"def position_taken?(location)\n !(board[location] == \" \" || board[location].nil?)\nend",
"def valid_position?(position)\n self[position].nil?\n end",
"def position_taken?(board, index)\n spot = board[index]\n if spot == \" \" || spot == \"\" || spot == nil\n false\n elsif spot == \"X\" || spot == \"O\"\n true\n end\nend"
] | [
"0.7555294",
"0.7524301",
"0.75096864",
"0.74630916",
"0.7401194",
"0.7384155",
"0.7382516",
"0.7340435",
"0.733096",
"0.733096",
"0.73286694",
"0.73074114",
"0.7291124",
"0.7287067",
"0.72860986",
"0.72836024",
"0.7267499",
"0.72665644",
"0.7241557",
"0.72345066",
"0.720437",
"0.7199865",
"0.7194314",
"0.7189804",
"0.7180648",
"0.7178879",
"0.7161848",
"0.71421266",
"0.71320045",
"0.7126022",
"0.7116492",
"0.7107326",
"0.70954585",
"0.70894116",
"0.708283",
"0.7077249",
"0.70683557",
"0.7064866",
"0.70604455",
"0.70557696",
"0.7054782",
"0.70547414",
"0.7044798",
"0.7033051",
"0.70328397",
"0.70328397",
"0.7017693",
"0.7012599",
"0.7011534",
"0.701047",
"0.70006144",
"0.70006144",
"0.69858116",
"0.69787747",
"0.6975767",
"0.6975649",
"0.6974266",
"0.69725806",
"0.69725806",
"0.69696814",
"0.6965569",
"0.69633305",
"0.69633305",
"0.69633305",
"0.6960453",
"0.6960369",
"0.69542503",
"0.69505835",
"0.694849",
"0.6945302",
"0.6945302",
"0.69450474",
"0.69428265",
"0.69425976",
"0.6940557",
"0.6940557",
"0.69337076",
"0.693076",
"0.693055",
"0.69303334",
"0.6927559",
"0.69264567",
"0.6917562",
"0.69147617",
"0.6914304",
"0.6903689",
"0.6875236",
"0.68742067",
"0.6871444",
"0.6867084",
"0.6866602",
"0.68656474",
"0.68603975",
"0.6859194",
"0.685191",
"0.6851485",
"0.6849247",
"0.6847057",
"0.68424773",
"0.6841055",
"0.6840068"
] | 0.0 | -1 |
checks if move is valid | def valid_move?(board, position)
position = (position.to_i - 1)
if position.between?(0, 8) && !position_taken?(board, position)
true
else false
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_move_valid(move)\n @moves.include? move\n end",
"def valid_move?(move)\n\t\tif in_bounds?(move) && empty_space?(move) && any_converted_pieces?(move)\n\t\t\treturn true\n\t\telse \n\t\t\treturn false\n\t\tend \n\tend",
"def valid_move?(move)\n move.to_i.between?(1,9) && !taken?(move)\n end",
"def valid?(move)\n @board.valid_move?(move)\n end",
"def validate_move(move) \n move_from_file = @data[\"moves\"][move]\n move_from_file ? valid = true : valid = false\n end",
"def valid_move?\n\t\tvalid_1 = (0..2).include? (@take_from)\n\t\tvalid_2 = (0..2).include? (@move_to)\n\t\tif valid_1 == false || valid_2 == false\n\t\t\tputs \"I'm sorry, please input your move in a 'x,y' format, ensuring that you are selecting numbers between 1 and 3!\"\n\t\t\tmove_input\n\t\telsif @pegs[@take_from][0] == nil\n\t\t\tputs \"I'm sorry, I'm not in the mood for a philosophical debate so let's just agree that you cannot move nothing and you can try again.\"\n\t\t\tmove_input\n\t\tend\n\tend",
"def valid_move?(move_index)\r\n #valid if position is NOT taken\r\n valid = !self.position_taken?(move_index)\r\n if valid == true\r\n if move_index.between?(0,8)\r\n valid = true\r\n else\r\n valid = false\r\n end\r\n end\r\n valid\r\n end",
"def validates_move move\n\t\[email protected]?(move) && move.index.between?(1,10)\n\tend",
"def valid_move?(move)\n move = move.to_i if move.is_a? String\n return false unless move.is_a? Integer\n move.between?(1, 9) && !position_taken?(move-1) \n end",
"def valid_move?(position)\n position.between?(0,8) && !position_taken?(position)\n end",
"def check_valid(move)\n\n\t\tif @board[move[0]][move[1]] != \"-\"\n\t\t\treturn false\n\t\telse\n\t\t\treturn true\n\t\tend\n\n\tend",
"def valid_move?\n\t\t# Now let's make sure all of the moves are valid.\n\t\t# I'll do this by seeing if the sorted version of each\n\t\t# column equals the @board version.\n\t\ttemp_board = Marshal.load(Marshal.dump(@board))\n\t\ttemp = temp_board[@move_from].shift\n\t\ttemp_board[@move_to].unshift(temp)\n\n\t\ttemp_board.each do |column|\n\t\t\tif column.sort != column\n\t\t\t\treturn false\n\t\t\tend\n\t\tend\n\t\t# If they all pass, we're good!\n\t\treturn true\n\tend",
"def valid_move?(new_x, new_y)\n true\n end",
"def valid_move?(board, position)\n position = position.to_i\n return false if !valid_position?(position)\n return false if position_taken?(board, position)\n return true\nend",
"def check_if_moveisvalid(move)\n @all_available_moves.each do |avail_move|\n return true if move.is_equal_to?(avail_move)\n end\n return false\n end",
"def valid_move?(position)\n !taken?(position) && position.to_i >0 && position.to_i <=9\n end",
"def is_valid?(_destination)\n raise NotImplementedError, \"Must be able to detect if a move is valid!\"\n end",
"def valid_move?(location)\n location.to_i.between?(1,9) && !position_taken?(location.to_i-1)\n end",
"def valid_move?(position)\n if !position_taken?(position) && position.between?(0,8)\n true\n else\n false\n end\n end",
"def valid_move?(input)\n (0..8).include?(input) && !position_taken?(input)\n end",
"def valid_move_seq?(move_seq)\n test_board = @board.dup_board\n # debugger\n if test_board[@position].perform_moves!(move_seq)\n return true\n else\n raise InvalidMoveError\n end\n end",
"def validate_move(move)\n @rules_matrix.has_key?(move)\n end",
"def valid_move?(move)\n # Array of all posiible moves , check the board and map out the possible moves from there.\n end",
"def check_move(start_pos, end_pos)\n # p start_pos\n # puts end_pos\n\n if self[[start_pos[0], start_pos[1]]].valid_move?(start_pos, end_pos, self)\n self[[start_pos[0], start_pos[1]]].move(start_pos, end_pos, self)\n end\n end",
"def valid_move?(position)\n index=position.to_i - 1\n index.between?(0, 8) && !(position_taken?(index))\n end",
"def check_valid_move to_move\r\n\t\t\r\n\t\tif to_move == 0\r\n\t\t\tif driver.location.west_road == nil\r\n\t\t\t\treturn false\r\n\t\t\telse\r\n\t\t\t\treturn true\r\n\t\t\tend\r\n\t\t\r\n\t\telsif to_move == 1\r\n\t\t\tif driver.location.north_road == nil\r\n\t\t\t\treturn false\r\n\t\t\telse\r\n\t\t\t\treturn true\r\n\t\t\tend\r\n\t\t\r\n\t\telsif to_move == 2\r\n\t\t\tif driver.location.east_road == nil\r\n\t\t\t\treturn false\r\n\t\t\telse\r\n\t\t\t\treturn true\r\n\t\t\tend\r\n\t\t\r\n\t\telsif to_move == 3\r\n\t\t\tif driver.location.south_road == nil\r\n\t\t\t\treturn false\r\n\t\t\telse\r\n\t\t\t\treturn true\r\n\t\t\tend\r\n\t\telse\r\n\t\t\traise \"The location does not exist. Error\"\r\n\t\t\r\n\t\tend\r\n\t\treturn false\r\n\tend",
"def validMove(piece, newLocation)\n # piece can move to any empty adjacent space.\n # might need to account for placing pieces. can be counted as a fly move i guess \n\n if newLocation == nil || piece == nil\n return false\n end\n\n # check if its a fly move. \n if @player1.isActive\n if @player1.numPlayedPieces <= 3\n fly = true \n else\n fly = false\n end\n else\n if @player2.numPlayedPieces <= 3\n fly = true \n else\n fly = false\n end\n end\n\n\n #checks if space is empty:\n if newLocation.isEmpty()\n # check if its a fly move\n if fly\n # if its a fly and the target location is empty its allowed. \n return true\n elsif piece.location == nil\n return true\n else\n # should return true if the move is valid.\n return @board.isAdjacent(piece,newLocation)\n end\n else\n # should the space is not empty, the move is invalid\n return false\n end\n\n end",
"def isValidMove(pos)\n\tif pos < 0 || pos > 8\n\t\tprint \"Invalid move. Try again human. \\n\"\n\t\treturn false\n\telsif @bo[pos] == '-' then\n\t\treturn true\n\telse \n\t\treturn false\n\tend\n end",
"def valid_move?(input)\n #checks that the attempted move is within the bounds of the game board\n input.between?(0, 8) && !position_taken?(input)\n end",
"def is_valid_move x,y\n return false unless (0..3) === x\n return false unless (0..3) === y\n return @field[x][y].player == 0\n end",
"def valid_move?(input_position)\n num = self.convert_to_i(input_position)\n num.between?(1, 9) && !self.taken?(num)\n end",
"def valid_move?(destination)\n occupant = @board[destination]\n result = false\n if occupant.nil? || (enemy? occupant)\n result = movement_rule(destination)\n end\n\n result\n end",
"def could_be_valid_move?\n return @board_gfx.is_draggingpiece_valid?\n end",
"def valid_move?(board, position)\n position.between?(0, 8) && !position_taken?(board, position)\nend",
"def valid_move?(x_des, y_des)\n ( no_x_move?(x_des) && standard_move?(x_des, y_des) ) ||\n ( promotion_move?(x_des, y_des) || pawn_capture_move?(x_des, y_des) )\n end",
"def valid_move?(index)\n puts \"Turn #{turn_count}\"\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(index)\n return index.between?(0, @board.length) && !position_taken?(index)\n end",
"def valid_move?(board, position)\n position_taken?(board, position) == false && position.between?(0, 8) ? true : false\nend",
"def valid_move?(position)\r\n @index = position.to_i-1\r\n if @index.between?(0,8) && !position_taken?(@index)\r\n return true\r\n else\r\n return false\r\n end\r\n end",
"def valid_move?(board, index)\n if board[index].nil? || position_taken?(board, index) || board[index] == \"X\" || board[index] == \"O\"\n false\n else\n true\n end\nend",
"def valid_move?(start_coords, end_coords)\n return false if end_coords.size == 0 # validate user input\n return true unless valid_move_chain(start_coords, end_coords).empty?\n false\n end",
"def valid_move?(index)\n\t\tindex < 9 && !position_taken?(index) ? true : false\n\tend",
"def valid_moves\n\n end",
"def validate_move?(move)\n return true if open_spots.include?(move)\n false\n end",
"def valid_move? (board, position)\n position = position.to_i - 1\n (position.between?(0,8)) && (position_taken?(board, position) == false)\nend",
"def valid_move?(position)\n if !position.is_a?(Integer)\n position = position.to_i\n end\n if(position>=1 && position<[email protected] && !position_taken?(position))\n return true\n end\n return false\n end",
"def valid_move?(destination)\n possible_moves.select do |move|\n on_board?(move) && open?(move)\n end\n\n possible_moves.include?(destination)\n end",
"def valid_move?(location)\n location.to_i.between?(1,9) && !taken?(location)\n end",
"def valid_move?(fir, sec)\n if (sec < 0) || (sec > 8)\n return false\n elsif position_taken?(fir,sec)\n return false\n else\n return true\n end\nend",
"def valid_move?(board, position)\n !position_taken?(board, position) && position.between?(0,8)\nend",
"def valid_move?(board, ix)\n if position_taken?(board, ix) == false && move_val?(ix) == true\n return true\n else\n false\n end\nend",
"def valid_move?(board, position)\n position.to_i.between?(1,9) && !position_taken?(board, position.to_i-1)\nend",
"def valid_move?(board, position)\n if !(position_taken?(board, position)) && position.between?(0, 8)\n return true\n else\n return false\n end\nend",
"def validate_player_move(move)\r\n \r\n #Return a value of false is the square has already been\r\n #selected\r\n return false if move == \"A1\" && $A1 != \" \"\r\n return false if move == \"B1\" && $B1 != \" \"\r\n return false if move == \"C1\" && $C1 != \" \"\r\n return false if move == \"A2\" && $A2 != \" \"\r\n return false if move == \"B2\" && $B2 != \" \"\r\n return false if move == \"C2\" && $C2 != \" \"\r\n return false if move == \"A3\" && $A3 != \" \"\r\n return false if move == \"B3\" && $B3 != \" \"\r\n return false if move == \"C3\" && $C3 != \" \" \r\n \r\n #Return a value of true if the square is available\r\n return true\r\n \r\n end",
"def valid_move?(position)\n if is_number?(position)\n if position.to_i.between?(0, 10)\n if position_taken?(position.to_i-1)\n false\n else\n true\n end\n else \n false\n end\n else\n false\n end\n end",
"def valid_move?(input)\n input.to_i.between?(1, 9) && !taken?(input)\n # binding.pry\n # input.to_i.between?(1, 9) && position(input) == \" \"\n end",
"def move_valid?(pos)\n return false unless board.in_bounds?(pos)\n return false if board.occupied?(pos) && board.grid[pos[0]][pos[1]].color == self.color\n true\n end",
"def valid_move?(board, index)\n index.between?(0,8) && !position_taken?(board, index) #if the position isn't taken and is on the board, the move must be valid\nend",
"def valid_move?(board,pos)\n if !position_taken?(board,pos.to_i-1) && pos.to_i.between?(1,9)\n return true\n elsif position_taken?(board,pos.to_i-1) && pos.to_i.between?(1,9)\n return false\n end\nend",
"def valid_move?(index)\n if position_taken?(index)\n false\n elsif position_taken?(index) == false && index.between?(0,8)\n true\n end\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?\n\t\[email protected]_on_table?(@robot_direction, @x, @y)\n\tend",
"def valid_move? move\n@board[move] == PIECE[:blank]\nend",
"def valid_move?(board, index)\n index.between?(0,8) && !position_taken?(board, index)\n end",
"def valid_move?(board, index)\n index.between?(0,8) && !position_taken?(board, index)\n end",
"def valid_move?(board, position)\n # position = position.to_i \n position.to_i. between?(1, 9) && !position_taken?(board, position.to_i-1)\nend",
"def valid_move?(index)\n index.between?(0, 8) && !position_taken?(index)\n end",
"def valid_move?(from_row, from_column, to_row, to_column)\n piece = @state[from_row][from_column]\n return false if piece == nil\n\n new_location = [to_row, to_column]\n return false unless piece.moves.include? new_location\n\n return pawn_valid_move?(piece, new_location, to_column, from_column) if\n piece.class == Pawn\n\n return false unless empty_location?([to_row, to_column]) || \n enemy_piece_at_location?(piece.color, new_location)\n\n unless piece.class == Knight || piece.class == King\n return no_pieces_in_between?(from_row, from_column, to_row, to_column)\n end\n\n true\n end",
"def valid_move?(input)\n\t\tinput.to_i.between?(1,9) && !taken?(input)\n\tend",
"def valid_move?(board, index)\n if !position_taken?(board, index) && index.between?(0, 8)\n true #is valid move\n else\n false\n end\nend",
"def valid_move?(board, position)\n position.to_i.between?(1,9) && !position_taken?(board,position.to_i-1)\n\nend",
"def valid_move?(board,position)\n valid = nil\n if position >= 0 && position <=8\n case position_taken?(board,position)\n when true\n valid = false\n when false\n valid = true\n end\n end\n\n return valid\nend",
"def valid_move?(board, position)\n position = position.to_i - 1\n if position_taken?(board, position)\n return false\n else\n if position.between?(0,8) && (board[position] != \"X\" || board[position] != \"O\")\n return true\n else\n return false \n end\n end\nend",
"def valid_move?(robot)\n x_pos = robot.x_position\n y_pos = robot.y_position\n dir = robot.direction\n invalid_east_move = (x_pos == @dimension) && (dir == 'EAST')\n invalid_west_move = x_pos.zero? && (dir == 'WEST')\n invalid_north_move = (y_pos == @dimension) && (dir == 'NORTH')\n invalid_south_move = y_pos.zero? && (dir == 'SOUTH')\n !(invalid_east_move || invalid_west_move || invalid_north_move || invalid_south_move)\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(index)\n index.between?(0,8) && !position_taken?(index)\n end",
"def valid_move?(board,position)\n\tif position.to_i.between?(1, 10) && empty_position?(board, position.to_i)\n\t\t\treturn true \n\telse\n\t\treturn false \n\tend\nend",
"def valid_move?(board, position)\n position = position.to_i\n if(position.between?(1,9))\n position -=1\n if(position_taken?(board, position))\n false\n else\n true\n end\n end\nend",
"def valid_moves\n moves.reject { |end_pos| move_into_check?(end_pos) }\n end",
"def move_valid?(x, y)\n coordinate_valid?(x, y) && !@visited[y][x]\n end",
"def move_valid?(x, y)\n coordinate_valid?(x, y) && !@visited[y][x]\n end",
"def valid_move?(piece, location)\n\t\tif valid?(piece, location) == false\n\t\t\treturn false\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, 1, 1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, -1, 1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, 1, -1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, -1, -1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif valid_jump?(piece, location) == nil\n\t\t\treturn false\n\t\telse\n\t\t\treturn true\n\t\tend\n\tend",
"def valid_move?(piece, location)\n\t\tif valid?(piece, location) == false\n\t\t\treturn false\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, 1, 1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, -1, 1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, 1, -1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif location_at_offset?(piece, location, -1, -1)\n\t\t\treturn true\n\t\tend\n\t\t\n\t\tif valid_jump?(piece, location) == nil\n\t\t\treturn false\n\t\telse\n\t\t\treturn true\n\t\tend\n\tend",
"def valid_move?(board,position)\n if position.to_i.between?(1,9) && !position_taken?(board,position.to_i-1)\n true\n else\n end\nend",
"def valid_move?(board, position)\n position = position.to_i - 1\n if position.between?(0, 8) && !position_taken?(board, position)\n true\n end\nend",
"def valid_move_seq? move_sequence\n dup_board = self.board.dup\n \n begin\n dup_board.perform_moves!(move_sequence)\n rescue InvalidMoveError => e\n puts e.message\n else\n return true\n end \n end",
"def valid_move?(board, index)\r\n index.between?(0, 8) && !position_taken(board, index) ? true : false \r\nend",
"def valid_move?(index)\n index.between?(0,8) && ! position_taken?(index)\n end",
"def valid_move? (board, index)\n if index.between?(0, 8) && !position_taken?(board, index)\n true \n end \nend",
"def valid_move?(board, index)\n if position_taken?(board, index) or !(index >= 0 and index < 9)\n false\n else\n true\n end\nend",
"def valid_piece_movement?(coordinates)\n row = coordinates[:row]\n column = coordinates[:column]\n @active_piece.moves.any?([row, column]) || @active_piece.captures.any?([row, column])\n end",
"def valid_move?(index)\n if position_taken?(index)\n false\n elsif index < 0 || index > 8\n false\n else\n true \n end\n end",
"def valid_move?(board, position)\n indexed_position = position.to_i - 1\n indexed_position.between?(0,8) && !position_taken?(board, indexed_position)\nend",
"def valid_move?(board, index)\n if index.between?(0,8) && !position_taken?(board, index)\n puts \"this is a valid move\"\n return true\n else\n return false\n end\nend",
"def valid_move?(position)\n position && @maze[position] != \"*\" && @times_visited[position] < 2 && position[0] < @maze.maze.length && position[1] < find_max_row_length \n end",
"def valid_move?(board,user_input)\n taken = position_taken?(board,user_input)\n valid_input = user_input.between?(0,8)\n valid_move = nil\n if(taken)\n valid_move = false\n else\n valid_move = true\n end\n if(valid_move && valid_input)\n true\n else\n false\n end\nend",
"def valid_move?(position)\n !taken?(position) && position.ord.between?(48, 57)\n end"
] | [
"0.84806347",
"0.83525056",
"0.83269006",
"0.8323307",
"0.83062106",
"0.82856065",
"0.8222756",
"0.8198662",
"0.81965184",
"0.81256986",
"0.8086587",
"0.8070863",
"0.80679417",
"0.80097437",
"0.7989664",
"0.79601264",
"0.7947462",
"0.79464006",
"0.7921848",
"0.7902719",
"0.7901498",
"0.7900651",
"0.7888318",
"0.78813326",
"0.78810847",
"0.7876398",
"0.78621185",
"0.7851603",
"0.78463876",
"0.78422475",
"0.78364336",
"0.7832245",
"0.78222704",
"0.7800165",
"0.77987117",
"0.7796253",
"0.77784944",
"0.7773204",
"0.7772371",
"0.77723354",
"0.7768985",
"0.7737851",
"0.77277803",
"0.7727404",
"0.7724009",
"0.77237463",
"0.7721152",
"0.7721101",
"0.7699397",
"0.76975137",
"0.769549",
"0.7691159",
"0.76838726",
"0.7660542",
"0.7659396",
"0.7642976",
"0.76383066",
"0.76343405",
"0.762307",
"0.76210797",
"0.7620736",
"0.76158464",
"0.76148176",
"0.7612144",
"0.7608526",
"0.7608526",
"0.7598227",
"0.75950956",
"0.7590735",
"0.75906885",
"0.75901735",
"0.7590001",
"0.75854295",
"0.75806755",
"0.7580561",
"0.7579977",
"0.7579977",
"0.7579977",
"0.7579977",
"0.7578161",
"0.757593",
"0.75714344",
"0.75704026",
"0.75704026",
"0.75669616",
"0.75669616",
"0.7566014",
"0.75636697",
"0.75579214",
"0.7557604",
"0.7547002",
"0.7545733",
"0.7545455",
"0.75416833",
"0.7539809",
"0.75392",
"0.7537809",
"0.75375915",
"0.75363135",
"0.75306547"
] | 0.7558249 | 88 |
defines a turn. asks user for input and loops if invalid. | def turn(board)
puts "Please enter 1-9:"
position = gets.strip()
valid = false
while valid == false
if valid_move?(board, position)
move(board, position, current_player(board))
valid = true
else
puts "Invalid Move. Please enter 1-9:"
position = gets.strip()
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn\n while true\n puts \"Please enter 1-9:\"\n answer = gets.chomp\n if(valid_move?(answer))\n move(answer)\n display_board\n return\n end\n end\n end",
"def take_turn\n puts \"#{player.name}'s turn. Enter 0-9:\"\n input = gets.strip\n if board.valid_move?(input)\n board.move(input, player)\n else\n puts \"Please enter valid move:\"\n take_turn(board, player)\n end\n board.display\n end",
"def turn\n # Asks user for input.\n puts \"Please enter 1-9:\"\n # Places the user's answer into the variable 'input'.\n input = gets.strip\n # Uses the conversion method to place it into variable 'index'.\n index = input_to_index(input)\n # Goes through an if/else loop to check if move is valid.\n if valid_move?(index)\n # Adds the player's input if valid.\n move(index, current_player)\n # Displays the board back to the player in the CLI afterwards.\n display_board()\n else\n # Recursively calls the turn method if an incorrect move is played.\n turn()\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n is_valid = valid_move?(index)\n if is_valid === true\n current_turn = current_player\n move(index,current_turn)\n display_board\n else\n puts 'Please enter correct input'\n puts \"Please enter 1-9:\"\n input = gets.strip\n end\n end",
"def turn(board)\n\n#ask for input\n puts \"Please enter 1-9:\"\n\n#get input\ninput = gets.strip\n\n#if input is valid\nif (valid_move?(board, input))\n\n # make the move for input\n move(board, input)\n\n#else\nelse\n\n # ask for input again until you get a valid input\n puts \"Please enter a valid move.\"\n turn(board)\n\n#end\nend\n\n#show the board\ndisplay_board(board)\nend",
"def turn \n puts \"Make a move compadre\"\n input = gets.strip\n location = input_to_index(input)\n if valid_move?(location)\n tictac = current_player\n move(location, tictac)\n display_board\n else\n turn\n end\n end",
"def turn()\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player())\n display_board()\n else\n turn()\n end\n end",
"def start_turn \n if @game_over == false\n @game.print_grid\n puts \"Pick an empty box, \" + print_name(@game.current_player) + \". Resitance is \" + pink(\"futile.\")\n player_choice = STDIN.gets.chomp \n valid = \"123456789\".split(\"\") \n unless valid.include? player_choice\n puts \"Enter a number from \" + pink(\"1 to 9\") + \", resistance discouraged... with \" + pink(\"deadly neurotoxin\")\n start_turn\n end\n if @game.blank_box?(player_choice) \n control(player_choice) \n else \n puts blue(\"That square is taken\") + \". Since you cannot see that obvious fact we have taken points off your \" + blue(\"final grade\") + \". If you were not an \" + pink(\"orphan\") + \" your family would be ashamed\"\n start_turn\n end\n end\n end",
"def turn\n puts \"Choose a spot between 1-9\"\n spot = gets.strip\n #calls #input_to_index, #valid_move?, and #current_player\n #makes valid moves and displays the board\n #loop back spot/input if/else statement to ask for input again after a failed validation\n spot = input_to_index(spot)\n if valid_move?(spot)\n move(spot, current_player)\n else\n turn\n end\n display_board\n end",
"def turn\r\n puts \"Please enter 1-9:\"\r\n user_input = gets.strip\r\n user_move = input_to_index(user_input)\r\n \r\n if valid_move?(user_move)\r\n move(user_move,current_player)\r\n display_board\r\n else\r\n turn\r\n end\r\n end",
"def turn()\n player = current_player()\n puts \"Player #{player}, Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n\n is_valid = false\n until is_valid\n if valid_move?(index)\n move(index, player)\n display_board()\n is_valid = true\n else\n puts \"Invalid Selection! Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n end\n end\n end",
"def turn\n display_board\n puts \"Please enter 1-9:\"\n input = gets.strip\n if !valid_move?(input)\n turn\n end\n move(input, current_player)\n display_board\nend",
"def turn\n puts \"Please enter 1-9:\"\n location = gets.strip\n if valid_move?(location)\n token = current_player #This was not clear in the instructions on how to get the correct token\n move(location, token)\n else\n turn\n end\n display_board\n end",
"def turn\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n index = input_to_index(user_input)\n\n until valid_move?(index)\n puts \"Invalid Move! Try again.\"\n user_input = gets.strip\n index = input_to_index(user_input)\n\n end\n\n move(index, current_player)\n display_board\n end",
"def turn\n puts \"Please enter 1-9:\"\n user_input = gets.chomp\n user_input = input_to_index( user_input )\n if valid_move?( user_input ) == true\n puts \"Valid move was made\"\n character = current_player\n move( user_input, character )\n display_board\n else\n while valid_move?( user_input ) == false\n puts \"Please enter a valid move: \"\n user_input = gets.chomp\n user_input = input_to_index( user_input )\n end\n if valid_move?( user_input ) == true\n puts \"Valid move was made\"\n character = current_player\n move( user_input, character )\n display_board\n end\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player)\n display_board\n else\n turn\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player)\n display_board\n else\n turn\n end\n end",
"def turn\n move_input = current_player.move\n if !board.valid_move?(move_input) # if #valid_move false\n puts \"That is not a valid move. Please try again.\\n\"\n turn\n else\n board.update(move_input,current_player)\n board.display\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n position = input_to_index(input)\n\n if valid_move?(position)\n player = current_player\n move(position, player)\n display_board\n else\n turn\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n value = current_player\n move(index, value)\n display_board\n else\n turn\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets\n go = input_to_index(input)\n if valid_move?(go)\n move(go, current_player)\n display_board\n else\n turn\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player)\n display_board\n else\n turn\n end\n end",
"def turn(board)\n display_board(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n \n ##if valid_move?(board, input) == true\n ##display_board(board)\n if valid_move?(board, input) == false\n turn(board)\n else\n move(board, input)\n display_board(board)\n end\n \nend",
"def turn(board)\n while true\n puts \"Please enter 1-9:\"\n answer = gets.chomp\n if(valid_move?(board, answer))\n move(board, answer)\n display_board(board)\n return\n end\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n position = gets.chomp\n\n while !valid_move?(position)\n puts \"Please enter 1-9:\"\n position = gets.chomp\n end\n\n move(position, player_move = current_player)\n\n display_board\n end",
"def turn\r\n current_player = self.current_player\r\n #Ask the user for, and obtain, their move, a position between 1-9.\r\n print \"#{current_player}, enter your move (1-9): \"\r\n move_index = gets.chomp\r\n print \"\\n\"\r\n \r\n #Translate user input to valid index\r\n move_index = self.input_to_index(move_index)\r\n \r\n #Check if user input is valid move\r\n valid = false\r\n while !valid do\r\n if self.valid_move?(move_index)\r\n #If valid, make the move and display the board.\r\n self.move(move_index, current_player)\r\n self.display_board\r\n valid = true\r\n else\r\n #If invalid, ask for a new move until a valid move is received.\r\n puts \"That is not a valid move.\"\r\n print \"#{current_player}, enter your move (1-9): \"\r\n move_index = gets.chomp\r\n print \"\\n\"\r\n move_index = self.input_to_index(move_index)\r\n end\r\n end\r\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n character = current_player\n if valid_move?(index)\n move(index, character)\n display_board\n else\n # puts \"Invalid move\"\n turn\n end\n end",
"def turn\n #asks for user input, converts input to integer\n puts \"Enter the position you like to play (1-9): \"\n user_input = gets.strip\n\n #if move is valid, accepts move as index and displays new board\n if valid_move?(user_input)\n token=current_player\n move(user_input, token)\n display_board\n else\n turn\n end\n end",
"def turn\n puts \"Please enter 1-9: \"\n position = gets.chomp\n if valid_move?(position)\n move(position, current_player)\n else\n turn\n end\n display_board\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n user_input = gets.strip # Gets user input\n index = input_to_index(user_input) # Passes user input to input_to_index method as argument\n if valid_move?(board, index) == true # Test Code not valid then turn(board) to run again\n move(board, index, value = \"X\")\n display_board(board)\n else\n turn(board)\n end\n end",
"def turn(board)\n truthy = false\n until(truthy == true)\n puts \"Please enter 1-9:\"\n spotcheck = gets.strip\n truthy = valid_move?(board, spotcheck)\n end\n\n move(board, spotcheck)\n display_board(board)\n\nend",
"def turn\n puts \"Please enter 1-9:\"\n move = current_player.move(@board);\n if @board.valid_move?(move)\n @board.update(move, current_player);\n @board.display;\n else\n turn;\n end\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n if valid_move?(board,input)\n move(board,input,current_player(board))\n else\n turn(board)\n end\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n if valid_move?(board, input)\n player = current_player(board)\n move(board, input, player)\n else\n turn(board)\n end\n\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n index = input_to_index(user_input)\n token = current_player(board)\n if valid_move?(board,index)\n puts 'valid move'\n move(board, index, token)\n display_board(board)\n else\n puts 'try again'\n turn(board)\n end\n display_board(board)\nend",
"def turn\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n user_input = input_to_index(user_input)\n if valid_move?(user_input)\n move(user_input, current_player)\n else \n turn\n end\n display_board\nend",
"def turn \n\n puts \"Please enter a position between 1-9. \\n\"\n\n position = gets\n\n if !position_taken?(position) && valid_move?(position)\n move(position,current_player)\n display_board\n elsif position_taken?(position) || !valid_move?(position)\n puts \"Invalid move. Please re-enter a position between 1-9. \\n\"\n position = gets\n end\n end",
"def turn\n\nputs \"Please enter 1-9:\"\nposition = gets.chomp\n\n if valid_move?(position) == false\n turn\n else\n move(position, current_player)\n display_board\n end\n\nend",
"def not_valid\n display_board\n puts \"Input invalid please try again\"\n turn\n end",
"def turn(board)\n player = current_player(board)\n puts \"It's #{player}'s turn!\"\n puts \"Please enter 1-9:\"\n input = gets.strip\n i = input_to_index(input)\n if valid_move?(board, i)\n move(board, i, current_player(board))\n elsif valid_move?(board, i) == false\n puts \"Sorry, that move isn't valid. Try again.\"\n puts \"\\n\"\n puts turn(board)\n end\nend",
"def turn\n puts \"#{@current_player.name}\\'s turn. Choose your cell (1-9)\" \n choice = gets.chomp.to_i\n if choice > 9 || choice < 1\n puts \"Warning : number must be between 1 and 9\"\n elsif @current_player.move(choice) != false\n @winner = @current_player if @current_player.winner?\n @turn += 1\n switch_player\n end\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n if !valid_move?(board, input) \n turn(board)\n end\n move(board, input, current_player(board))\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n if !valid_move?(board, input)\n turn(board)\n end\n move(board, input, current_player(board))\n display_board(board)\nend",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player)\n display_board\n else\n turn\n end\n end",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index, current_player)\n display_board\n else\n turn\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(index)\n move(index,current_player)\n display_board\n else\n turn\n end\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n position = input_to_index(input)\n \n if valid_move?(board, position) == true\n move(board, position, current_player(board))\n display_board(board)\n else\n until valid_move?(board, position) == true\n turn(board)\n break\n end\n end\nend",
"def turn(board)\n player = current_player(board)\n puts \"Player #{player}, Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n\n is_valid = false\n until is_valid\n if valid_move?(board, index)\n move(board, index, player)\n display_board(board)\n is_valid = true\n else\n puts \"Invalid Selection! Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n end\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n index = input_to_index(user_input)\n if valid_move?(index) == true\n move(index, current_player)\n else\n turn\n end\n display_board\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n if valid_move?(board, input)\n player_character = current_player(board)\n move(board, input, player_character)\n else\n turn(board)\n end\n display_board(board)\nend",
"def turn \n\t\tputs \"\"\n\t\tputs current_player + \", Enter a square to take:\"\n\t\tindex = gets.strip\n\t\tindex = input_to_index(index)\n\t\tif valid_move?(index)\n\t\t\tmove(index, current_player)\n\t\telse \n\t\t\tputs \"Invald space, try again\" \n\t\tend\n\tend",
"def turn(board)\r\n # if draw?(board)\r\n # puts \"Cat's Game!\"\r\n # elsif over?(board) \r\n # puts \"Congratulations #{winner(board)}!\"\r\n # else\r\n puts \"Please enter 1-9:\"\r\n input = gets.strip\r\n index = input_to_index(input)\r\n if valid_move?(board, index)\r\n token = current_player(board)\r\n player_move(board, index, token)\r\n display_board(board)\r\n else\r\n turn(board)\r\n end\r\n # end\r\nend",
"def turn(board)\n player = current_player(board)\n got_valid = false\n puts \"Please choose a position between 1-9:\"\n while got_valid == false\n user_input = gets.strip\n position = input_to_index(user_input)\n if valid_move?(board, position)\n move(board, position, player)\n display_board(board)\n got_valid = true\n end\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n char = current_player\n if valid_move?(index)\n move(index, char)\n display_board\n else\n turn\n end\nend",
"def turn\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n char = current_player\n if valid_move?(index)\n move(index, char)\n display_board\n else\n turn\n end\nend",
"def turn(board)\n input = ask_move\n index = input_to_index(input)\n if (valid_move?(board, index) == true)\n move(board, index)\n elsif (valid_move?(board, index) == false)\n puts \"This is not a valid move.\"\n false\n while (turn(board) == false)\n turn(board)\n end\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n user_number = gets.strip\n index = input_to_index(user_number)\n if !(valid_move?(board,index)) \n puts \"Not a valid move. Try again.\"\n turn(board)\n else\n move(board, index, sign)\n end\nend",
"def turn \n player = current_player\n puts \"Player '#{player}' enter a move [1-9]\"\n input = gets.chomp \n index = input_to_index(input)\n if valid_move?(index)\n move(index,player)\n display_board\n else \n turn\n end\n end",
"def turn(board)\n \n loop do\n puts \"Please enter 1-9:\"\n index = input_to_index( gets.chomp )\n if valid_move?( board, index )\n move( board, index)\n display_board( board )\n break\n else\n puts \"That was an invalid entry\"\n end\n end\nend",
"def turn(board)\n # ask the user for input:\n puts \"Please enter 1-9:\"\n # gets the user input\n input = gets.strip\n # calls the input_to_index method\n index = input_to_index(input)\n #validates the input correctly\n if valid_move?(board, index)\n # makes valid move\n move(board, index, \"X\")\n else\n # asks for input again after a failed validation\n turn(board)\n end\n # displays a correct board after a valid turn\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n \n if valid_move?(board, index) == true\n move(board, index)\n display_board(board)\n else\n until valid_move?(board, index) == true\n turn(board)\n break\n end\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n position = gets.chomp\nif valid_move?(board, position)\n move(board, position)\n display_board(board)\nelse\n turn(board)\nend\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n position = input_to_index(input)\n token = current_player(board)\n if valid_move?(board, position)\n move(board, position, token)\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n valid_move = false\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n index = input_to_index(user_input)\n valid_move = valid_move?(board, index)\n if valid_move\n token = current_player(board)\n move(board, index, token)\n else\n turn(board)\n end\nend",
"def turn(board)\n#This is the initial prompt telling our user to input\n puts \"Please enter 1-9:\"\n#this gets our user input\n user_input= gets.strip\n#I set the index variable for later methods to = the outcome of the input to index method\n index = input_to_index(user_input)\n#If the outcome of the valid move method is true then run the board method and display the board\n if valid_move?(board, index) == true\n move(board, index, char = \"X\")\n display_board(board)\n#if not run the turn method again\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n valid = valid_move?(board,index)\n\n if !valid_move?(board,index)\n turn(board)\n else\n token = current_player(board)\n move(board, index, token)\n display_board(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board,index)\n move(board,index,current_player(board))\n else\n puts \"Hey, pay attention!\"\n turn(board)\n end\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, character = \"X\")\n display_board(board)\n else\n puts \"That is an invalid move\"\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n input = input_to_index(input)\n if !valid_move?(board, input)\n\t turn(board)\n end\n move(board,input,current_player(board))\n display_board(board)\nend",
"def turn(board)\nputs \"Please enter 1-9:\"\nuser_input = gets.strip\nindex = input_to_index(user_input)\nif !valid_move?(board, index) #asks for input again is the input is not valid\n turn(board)\nelse #if the input is valid makes the move then\n move(board, index, current_player(board))\n end\n display_board(board)\nend",
"def turn\n\t\t\t@turns += 1\n\t\t\t@guess_letter = gets[0].downcase\n\t\t\tshow_matches\n\t\t\tcheck_win\n\t\tend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n puts \"Incorrect entry. Try again.\"\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n user_input = gets.strip\n arr_index = input_to_index(user_input)\n position = current_player(board)\n\n if !valid_move?(board, arr_index)\n puts \"Please enter a different option\"\n user_input = gets.strip\n else\n move(board, arr_index, position)\n display_board(board)\n end\n\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board,index)\n # puts \"Please enter X or O\"\n # xo = gets.strip\n puts \"The move is valid\"\n move(board,index,current_player(board))\n display_board(board)\n else\n puts \"Input invalid and provide valid location\"\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\n end",
"def take_a_turn\n puts \"Select a position on the board from 1 to 9: \"\n user_input = gets.chomp\n user_input = input_to_index(user_input)\n was_valid_move = valid_move? user_input\n\n if was_valid_move\n @board[user_input] = @current_player\n @turns_taken += 1\n @current_player = @current_player == \"X\" ? \"O\" : \"X\" \n else\n if position_taken? user_input \n puts \"That position is taken!\" \n else \n \"Invalid move!\"\n end\n end\n end",
"def turn()\n puts \"Please enter 1-9:\"\n input = gets.strip\n intger=input.to_i\n #position = intger.to_i -1\n if valid_move?(input)\n move( intger,current_player())\n display_board()\n else\n turn()\n end\nend",
"def turn\n input = current_player.move(board)\n if board.valid_move?(input)\n board.update(input, current_player)\n board.display\n else\n board.display\n turn\n end\n end",
"def turn\n puts \"\"\n puts \" \" * 35 + \"c'est au tour à #{@current_player.name} de joué (1-9): \"\n puts \"\"\n print \" \" * 40 + \"> \"\n choice = gets.chomp.to_i\n if choice > 9 || choice < 1\n puts \"Tu te trompe de touche jeune apprentie\"\n elsif @current_player.move(choice) != false\n @winner = @current_player if @current_player.winner?\n @turn += 1\n switch_player\n end\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip #get user input and store in variable 'input'\n index = input_to_index(input) #convert user response into an integer and subtract 1\n\n\n # maybe need something (like an IF stmt) to check for if the position is not occupied with an X or O,\n # make the move, otherwise run the Turn method again.\n if valid_move?(board, index) #check if user input is in correct range of array 0-8, and position taken is true.\n move(board, index)\n display_board(board) #display the board after all these above checks\n else\n turn(board)\n end\n\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index)\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index)\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n user_input = gets\n index = input_to_index(user_input)\n until valid_move?(board, index)\n puts \"Please enter 1-9:\"\n user_input = gets\n index = input_to_index(user_input)\n end\n move(board, index, \"X\")\n display_board(board)\nend",
"def turn(board)\n puts 'Please enter 1-9:'\n user_input = gets.strip\n index = input_to_index(user_input)\n\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\r\n puts \"Please enter 1-9:\"\r\n user_input = gets.strip\r\n index = input_to_index(user_input)\r\n if valid_move?(board, index)\r\n move(board, index, current_player(board))\r\n display_board(board)\r\n else\r\n turn(board)\r\n end\r\nend",
"def turn(board)\r\n puts \"Please enter 1-9:\"\r\n input = gets.strip\r\n index = input_to_index(input)\r\n if valid_move?(board, index)\r\n move(board, index)\r\n display_board(board)\r\n else\r\n turn(board)\r\n end\r\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index) == true\n move(board, index, token = \"X\")\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn\n input = current_player.move(board)\n\n if board.valid_move?(input)\n board.update(input, current_player)\n board.display\n else\n turn\n end\n end",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board,index)\n move(board,index,current_player(board))\n display_board(board)\n else \n puts 'Please make sure square is not taken and is between 1-9'\n turn(board)\n end\nend",
"def turn(board)\n index = -1\n player = current_player(board)\n until valid_move?(board, index) do\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n end\n move(board, index, player)\n display_board(board)\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index) == true\n move(board, index)\n else\n puts \"Not a valid entry, position must be between 1 and 9 and not be currently occupied\"\n turn(board)\n end\n display_board(board)\nend",
"def turn(board)\n print \"Please enter 1-9: \"\n input = gets.strip\n index = input_to_index(input)\n if valid_move?(board, index)\n move(board, index, current_player(board))\n display_board(board)\n else\n turn(board)\n end\nend",
"def turn(board)\n puts \"Please enter 1-9:\"\n position = gets.strip\n\n if valid_move?(board, position) #&& position_taken?(board, position)\n move(board, position, current_player = \"X\")\n puts \"Please enter 1-9 again:\"\n else\n puts \"Please enter a valid number\"\n turn(board)\n end\n\n display_board(board)\n\nend",
"def loop_turn(game)\n while !game.is_end_game?\n game.turn\n end\n game.winner\n puts \"Do you want to restart for the new round (Y/N)?\"\n choice = gets.chomp.upcase.strip\n if choice == \"Y\"\n game.new_round\n loop_turn(game)\n else\n game.end_game\n end\n end",
"def turn\n character = current_player\nputs \"Please enter 1-9:\"\nuser_input = gets.strip\nuser_input = user_input.to_i\nindex = input_to_index(user_input)\n if valid_move?(index) == true\n move(index, character)\n display_board\n else \n turn\n end\nend",
"def take_a_turn(input = nil)\n print \"Guess a letter: \"\n loop do\n input ||= gets.chomp.upcase\n if input == \"SAVE\"\n save_game\n puts \"GAME SAVED!\"\n break\n elsif input.length != 1 || !board.letters.include?(input)\n puts \"invalid entry. Try again: \"\n input = nil\n else\n @turns += 1\n self.letter = input\n break\n end\n end\n end"
] | [
"0.7670551",
"0.7667789",
"0.7618827",
"0.75318205",
"0.75185335",
"0.7506626",
"0.7491193",
"0.74801195",
"0.7477733",
"0.7466927",
"0.74490637",
"0.7443907",
"0.7439268",
"0.7423114",
"0.73930234",
"0.73921907",
"0.73921907",
"0.73790777",
"0.73764664",
"0.7375603",
"0.737133",
"0.7366599",
"0.7364052",
"0.73452383",
"0.7343054",
"0.73429215",
"0.7339453",
"0.73111594",
"0.7296457",
"0.729638",
"0.72813827",
"0.72783864",
"0.72650045",
"0.7259482",
"0.7257911",
"0.7257144",
"0.72558045",
"0.72550523",
"0.72542644",
"0.724648",
"0.72448564",
"0.7243936",
"0.72438",
"0.72416294",
"0.7230791",
"0.72218966",
"0.7214945",
"0.72124535",
"0.72028697",
"0.7200413",
"0.7193107",
"0.71591794",
"0.7158919",
"0.713671",
"0.713671",
"0.71342164",
"0.7131676",
"0.71205646",
"0.7119881",
"0.7114444",
"0.7111057",
"0.7110402",
"0.7080592",
"0.7080441",
"0.7079921",
"0.70688486",
"0.704854",
"0.70476454",
"0.7044798",
"0.70426244",
"0.703985",
"0.7035805",
"0.703278",
"0.7031907",
"0.70201063",
"0.70099634",
"0.7008449",
"0.7007245",
"0.6991708",
"0.6974103",
"0.6971902",
"0.6971902",
"0.6966629",
"0.6964043",
"0.6964003",
"0.6961835",
"0.6961817",
"0.6960666",
"0.6956179",
"0.6953556",
"0.695014",
"0.69496447",
"0.69496447",
"0.69496447",
"0.69494814",
"0.6949135",
"0.69438666",
"0.69420093",
"0.694062",
"0.69352955"
] | 0.69738567 | 80 |
Counts the number of turns that have been played | def turn_count(board)
turn_counter = 0
board.each do |turn|
if turn == "X" || turn == "O"
turn_counter += 1
end
end
turn_counter
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_count\n turns_played = 0\n @board.each do |index|\n if index != \" \"\n turns_played += 1\n end\n end\n return turns_played\n end",
"def turn_count\n count = 0\n @board.each do |player|\n if player == 'X' || player == 'O'\n count += 1\n end\n end\n return count\n end",
"def turn_count\n turns = 0\n @board.each do |spot|\n if spot==\"X\" || spot==\"O\"\n turns += 1\n end\n end\n return turns\n end",
"def turn_count\n counter = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n counter\n end",
"def turn_count\n count = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n count +=1\n end\n end\n count\n end",
"def turn_count()\n turns = 0\n \n @board.each do |position|\n if position.eql?(\"X\") || position.eql?(\"O\")\n turns += 1\n end\n end\n \n return turns\n end",
"def turn_count\n turns = 0\n @board.each do |position|\n if position == \"X\" || position == \"O\"\n turns += 1\n end\n end\n return turns\n end",
"def turn_count\r\n turn_count = 0\r\n @board.each do |space|\r\n if space != \" \"\r\n turn_count += 1\r\n end\r\n end\r\n turn_count\r\n end",
"def turn_count\n x_turns = @board.count(\"X\")\n o_turns = @board.count(\"O\")\n turn_count = x_turns + o_turns\n return turn_count\nend",
"def turn_count \n count = 0\n @board.each do |board_item|\n if board_item != \" \"\n count += 1\n end\n end\n count\n end",
"def turn_count\n counter = 0\n @board.each do |positions|\n if positions == \"X\" || positions == \"O\"\n counter += 1\n end\n end\n counter.to_i\n end",
"def turn_count(board)\n counter = 0\n board.each do | move |\n if move == \"X\" || move == \"O\"\n puts counter += 1\n end\n end\n counter #This should be the number of turns\nend",
"def turn_count\n num_turns = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n num_turns += 1\n end\n end\n return num_turns\n end",
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count\n @board.count{|position| position != \" \"}\n end",
"def turn_count\n\t\[email protected]{|token| token == \"X\" || token == \"O\"}\n\tend",
"def turn_count()\n count = 0\n index = 0\n loop do\n if position_taken?(index)\n count += 1\n end\n index += 1\n if index > 9 \n break\n end\n end\n return count\n end",
"def turn_count\r\n turns_so_far = 0\r\n @board.each do |arr_item|\r\n if arr_item == \"X\" || arr_item ==\"O\"\r\n turns_so_far += 1\r\n end\r\n end\r\n return turns_so_far\r\n end",
"def turn_count\n counter = 0\n @board.each do |position|\n\n if position == \"X\" || position == \"O\"\n counter += 1\n end\n\n end\n counter\n end",
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count\n turn = @board.reject {|position| position == \" \"}\n turn.size\n end",
"def turn_count(board)\n count = 0;\n board.each do |square|\n if square == \"X\" || square == \"O\"\n count +=1\n end\n end\n return count #return number of turns that have been played\nend",
"def turn_count()\n current_turn = 0\n @board.each do |space|\n if space != \" \"\n current_turn += 1\n end\n end\n return current_turn\n end",
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"} # << tweaked\n end",
"def tbs_turn_count\n $game_troop.turn_count\n end",
"def turn_count\n counter = 0\n @board.each do |index_taken|\n if index_taken == \"X\" || index_taken == \"O\"\n counter += 1\n end\n end\n counter\n end",
"def turn_count\n @board.count{|value| (value==\"X\" || value==\"O\")}\n #counter = 0\n #@board.each do |value|\n # if value ==\"X\" || value == \"O\"\n # counter+=1\n # end\n #end\n #counter\n end",
"def turn_count\n @board.count{|i| i != \" \"}\n end",
"def turns(count)\n puts count\nend",
"def turn_count\n turns = @board.count { |i| i == 'X' || i == 'O' }\n turns\nend",
"def turn_count\n count = 0\n @board.each do |token|\n if token.downcase == \"x\" || token.downcase == \"o\"\n count += 1\n end\n end\n count\nend",
"def turn_count\n turns = 0\n @board.each do |position| #can use .count here: board.count{|token| token == \"X\" || token == \"O\"}\n if position == \"X\" || position == \"O\"\n turns += 1\n end\n end\n turns\n end",
"def games_played\n self.results.to_a.count\n end",
"def turn_count(board)\n turn_counter = 0\n (board.length).times do |i|\n if position_taken?(board, i)\n turn_counter += 1\n end\n end\n\n return turn_counter\nend",
"def turn_count(board)\n play_count = 0\n board.each do |play|\n if play == \"X\" || play == \"O\"\n play_count += 1\n end\n end\n play_count\nend",
"def turn_count\n counter = 0\n @board.each do|position|\n if position == \"X\" || position == \"O\"\n counter += 1 \n end\n end\n return counter\nend",
"def turn_count(board)\r\n #returns the number of of turns that have been played\r\n counter = 0\r\n board.each do|element|\r\n if (element == \"X\") || (element == \"O\")\r\n counter += 1 \r\n end\r\n end\r\n return counter\r\nend",
"def turn_count(board)\n counter = 0;\n board.each do |slot|\n if(slot == \"X\" || slot == \"O\")\n counter += 1;\n end\n end\n return counter;\nend",
"def turn_count\n counter = 0\n @board.each do|element|\n\tif (element == \"X\") || (element == \"O\")\n \tcounter += 1\n\tend\n end\n return counter\nend",
"def turn_count\n count = 0\n cells.each {|pos| count += 1 if pos == \"X\" || pos == \"O\"}\n count\n end",
"def turn_count(board)\n turns = 0\n board.each do |spot|\n if spot==\"X\" || spot==\"O\"\n turns += 1\n end\n end\n return turns\nend",
"def number_of_turns_taken(board)\r\n counter = 0\r\n board.each do |token|\r\n if token == \"X\" || token ==\"O\"\r\n counter +=1\r\n end\r\n end\r\n counter\r\nend",
"def turn_count(board)\n turn_count = 0\n \n board.each do |counter|\n if counter == \"X\" || counter == \"O\"\n turn_count += 1\n end\n end\n \n turn_count\n end",
"def turn_count(board)\n count = 0\n\n board.each_with_index do |location, index|\n if position_taken?(board, index)\n count = count + 1\n end\n end\n\n count\nend",
"def turn_count(board)\n\n\toccupied_spaces = 0\n\n\tcounter = 0\n\twhile counter < board.size\n\t if position_taken?(board, counter)\n\t\t occupied_spaces += 1\t\t \nend \ncounter += 1\nend\noccupied_spaces\nend",
"def turn_count(board)\n count = 0\n board.each do |index|\n index == \"X\" || index == \"O\" ? count += 1 : nil\n end\n return count\n end",
"def num_games win_condition\n total_games = 0\n @game_objects.each do |game|\n total_games += 1 if game_meets_win_cond?(win_condition, game)\n end \n total_games\n end",
"def turn_count(board)\n counter = 0\n board.each do |turns|\n if turns == \"X\" || turns == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count(board)\n num_of_turns = 0\n board.each do |spot|\n if (spot == 'X' || spot == 'O')\n num_of_turns += 1\n end\n end\n num_of_turns\nend",
"def turn_count\n counter = 0\n @cells.each do |cell|\n if cell != \" \"\n counter += 1\n end\n end\n counter\n end",
"def turn_count(board)\n count = 0\n board.each do |space|\n if (space == 'X' || space == 'O')\n count += 1\n end\n end\n return count\nend",
"def turn_count\n counter = 0\n cells.each do |index|\n if index != \" \"\n counter += 1\n end\n end\n counter\n end",
"def number_correct\n count_of_correct_turns = 0\n\n @turns.each do |turn|\n if turn.correct? == true\n count_of_correct_turns += 1\n end\n end\n count_of_correct_turns\n end",
"def turn_count (board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count(board)\n turns = 0\n board.each do | space |\n if space == \"X\" || space == \"O\"\n turns += 1\n end\n end\n return turns\nend",
"def turn_count\n\t\tcells.count {|cell| cell == \"X\" || cell == \"O\"}\t\n\tend",
"def number_correct\n turns.count do |each_turn|\n each_turn.correct?\n end\n end",
"def turn_count(board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\";\n counter += 1;\n end\n end\n counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |box|\n if box == \"X\" || box == \"O\"\n counter += 1\nend\nend\n return counter\nend",
"def turn_count(board)\n #this counter keeps track of how many occupied spcaes there are\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter += 1\n end\n end\nreturn counter\nend",
"def games_played\n games.size\n end",
"def games_played\n games.size\n end",
"def turn_count(board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count(board)\n spaces_taken = 0\n board.each do |board_space|\n if board_space == \"X\" || board_space == \"O\"\n spaces_taken += 1 \n end\n end\n return spaces_taken\nend",
"def get_total_games_played\n return games.size\n end",
"def turn_count(board)\n counter = 0\n board.each do |move|\n if move == \"X\" || move == \"O\"\n counter += 1\nend\nend\ncounter\nend",
"def turn_count(board)\n count=0\n board.each do |position|\n if(position==\"X\"||position==\"O\")\n count+=1\n end\n end\n return count\nend",
"def turn_count(board)\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter +=1\n end\n end\n return counter\nend",
"def turn_count\n self.cells.count(\"X\") + self.cells.count(\"O\")\n end",
"def turn_count(board)\n count = 0\n board.each do |entry|\n if (entry == \"X\" || entry == \"O\")\n count += 1\n end\n end\n count\nend",
"def turn_count(board)\n counter = 0\n board.each do |count_turn|\n if count_turn == \"X\" || count_turn == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter += 1\n puts \"#{counter}\"\n end\n end\n counter\nend",
"def wins\n wins = 0\n self.teams.each do |team|\n wins += team.games_won.length\n end\n wins\n end",
"def turn_count(board)\n count=0\n board.each do |pos|\n if(pos==\"X\"||pos==\"O\")\n count+=1\n end\n end\n count\nend",
"def games_played\n @games_played = @games_played += 1\n end",
"def turn_count(board)\n counter = 0\n board.each do |q| \n if q != \" \"\n counter += 1\n #if q == \"X\" \n #count_x = count_x + 1 \n#elsif q == \"O\"\n #count_o = count_o + 1 \nend\nend\n#return count_x\n#return count_o\nreturn counter\nend",
"def turn_count\n count = 0\n @cells.each do |element|\n count += 1 if element != \" \"\n end\n count\n end",
"def get_total_games_played\n\t\treturn games.size\n\tend",
"def turn_count(board)\n # We need a variable that establishes an initial value, otherwise, it won't\n # know where to start\n counter = 0\n board.each do |character|\n if character == \"X\" || character == \"O\"\n counter += 1\n else\n end\n end\n# This return is necessary because methods NEED to return something (tell us what\n# it is doing, instead of just telling us it does know the answer)\n return counter\nend",
"def turn_count(board)\n # We need a variable that establishes an initial value, otherwise, it won't\n # know where to start\n counter = 0\n board.each do |character|\n if character == \"X\" || character == \"O\"\n counter += 1\n else\n end\n end\n# This return is necessary because methods NEED to return something (tell us what\n# it is doing, instead of just telling us it does know the answer)\n return counter\nend",
"def player1_count()\n\t\[email protected](@player1)\n\tend",
"def turn_count\n cells.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count(board)\n turn_counter = 0\n board.each do |spot|\n if spot == \"X\" || spot.upcase == \"O\"\n turn_counter +=1\n end\n end\n return turn_counter\nend",
"def turn_count(board)\n count = 0\n board.each do |occupied|\n if occupied == \"X\" || occupied == \"O\"\n #if count is =< to 9\n count = count + 1\n end\n end\n return count\nend",
"def winner_count\n end",
"def turn_count\n cells.count{ |space| space ==\"X\" || space ==\"O\" }\n end",
"def turn_count(board)\n counter = 0\n board.each do |token|\n if token == \"X\" || token == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count(board)\n x_counter = 0\n o_counter = 0\n board.each do |spot|\n\n if spot == \"X\"\n x_counter += 1\n\n elsif spot == \"O\"\n o_counter += 1\n end\n end\n\nreturn x_counter + o_counter\nend",
"def turn_count(board)\ncounter = 0\nboard.each do |board_x|\n if board_x == \"X\" || board_x == \"O\"\ncounter += 1\n end\n end\nreturn counter\nend",
"def turn_count(board)\n count = 0\n board.each do |value|\n if value ==\"X\" || value == \"O\"\n count +=1\n end\n end\n return count\nend",
"def number_correct\n @turns.count do |turn|\n turn.correct?\n end\n end",
"def turn_count #counts occupied positions!\n turn = 0 #start at position 0.\n @board.each do |index| #iterating through each spot on the board. Is it occupied?\n if index == \"X\" || index == \"O\" #if there is an X or O in that spot,\n turn += 1 #then you must turn!\n end\n end\n return turn #if there is not an X or O in that spot, take your turn and put your X or O there.\nend",
"def turn_count(board)\n counter = 0\n turns = 0\n board.each do |idx|\n if idx != \" \" && idx != \"\"\n turns += 1\n end\n counter += 1\n end\n return turns\nend",
"def turn_count\n cells.count {|cell| cell == \"X\" || cell == \"O\"}\n end",
"def turn_count(board)\n count= 0\n board.each do |token|\n if token == \"X\" || token == \"O\"\n count +=1\n end\n end\nreturn count\nend",
"def turn_count\n cells.count { |cell| cell == \"X\" || cell == \"O\" }\n end",
"def turn_count\n cells.count {|value| value == \"X\" || value == \"O\"}\n end",
"def turn_count(board)\n counter = 0\n board.each do |element|\n if element == \"O\" || element == \"X\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count(board)\ncurrent_turn = 0\nboard.each do |space|\n if space != \" \"\n current_turn += 1\n end\nend\nreturn current_turn\nend",
"def turn_count(board)\n counter = 0\n board.each do |index|\n if (index == \"X\" or index == \"O\")\n counter+=1\n end\n end\n return counter\nend"
] | [
"0.8064959",
"0.79076695",
"0.7888602",
"0.78305924",
"0.7827466",
"0.78259647",
"0.7804267",
"0.78042066",
"0.7801203",
"0.7786617",
"0.77736056",
"0.7733551",
"0.7703273",
"0.766613",
"0.76647145",
"0.7597591",
"0.7593198",
"0.7592888",
"0.75802505",
"0.75784916",
"0.75777817",
"0.75666505",
"0.75619936",
"0.7549027",
"0.7516856",
"0.7507613",
"0.7495712",
"0.7482362",
"0.74675566",
"0.74526024",
"0.74395514",
"0.7425619",
"0.74035674",
"0.7399672",
"0.7397836",
"0.7374769",
"0.7371175",
"0.7359419",
"0.7344348",
"0.72736055",
"0.72300446",
"0.721693",
"0.7209169",
"0.7189536",
"0.71883476",
"0.7178641",
"0.7168978",
"0.71634483",
"0.7154099",
"0.7145511",
"0.7144943",
"0.7142529",
"0.7139779",
"0.7126438",
"0.7115676",
"0.7101299",
"0.70914835",
"0.70856726",
"0.7085563",
"0.7079437",
"0.7079417",
"0.7079417",
"0.70772743",
"0.7075659",
"0.7070817",
"0.7067708",
"0.70644045",
"0.7047654",
"0.7044383",
"0.70414865",
"0.703203",
"0.70131016",
"0.70093983",
"0.6998066",
"0.6995749",
"0.69940114",
"0.6989554",
"0.6986614",
"0.6981531",
"0.6981531",
"0.69674534",
"0.69614655",
"0.69606346",
"0.6947457",
"0.6931646",
"0.6917882",
"0.6916121",
"0.69149935",
"0.6910565",
"0.6909013",
"0.69056803",
"0.6897799",
"0.6897173",
"0.68905944",
"0.6889722",
"0.6888141",
"0.6879785",
"0.6877094",
"0.68759066",
"0.68694204"
] | 0.7062202 | 67 |
Uses the turn_count method to determine if it is "X" or "O" turn. | def current_player(board)
turn_count(board) % 2 == 0 ? "X" : "O"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count #counts occupied positions!\n turn = 0 #start at position 0.\n @board.each do |index| #iterating through each spot on the board. Is it occupied?\n if index == \"X\" || index == \"O\" #if there is an X or O in that spot,\n turn += 1 #then you must turn!\n end\n end\n return turn #if there is not an X or O in that spot, take your turn and put your X or O there.\nend",
"def turn_count\n\t\[email protected]{|token| token == \"X\" || token == \"O\"}\n\tend",
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count\r\n turns_so_far = 0\r\n @board.each do |arr_item|\r\n if arr_item == \"X\" || arr_item ==\"O\"\r\n turns_so_far += 1\r\n end\r\n end\r\n return turns_so_far\r\n end",
"def turn_count\n @board.count{|token| token == \"X\" || token == \"O\"} # << tweaked\n end",
"def turn_count\n count = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n count +=1\n end\n end\n count\n end",
"def turn_count\n turns = 0\n @board.each do |position|\n if position == \"X\" || position == \"O\"\n turns += 1\n end\n end\n return turns\n end",
"def turn_count\n counter = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n counter\n end",
"def turn_count(board)\n turn_count = 0\n \n board.each do |counter|\n if counter == \"X\" || counter == \"O\"\n turn_count += 1\n end\n end\n \n turn_count\n end",
"def turn_count()\n turns = 0\n \n @board.each do |position|\n if position.eql?(\"X\") || position.eql?(\"O\")\n turns += 1\n end\n end\n \n return turns\n end",
"def turn_count\n counter = 0\n @board.each do |positions|\n if positions == \"X\" || positions == \"O\"\n counter += 1\n end\n end\n counter.to_i\n end",
"def turn_count(board)\n turn_counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n turn_counter += 1\n end\n end\n turn_counter\nend",
"def turn_count(board)\n turn = 0\n board.each do |character|\n if character == \"X\" || character == \"O\"\n turn += 1\n end\n end\n return turn\nend",
"def turn_count\n counter = 0\n @board.each do |position|\n\n if position == \"X\" || position == \"O\"\n counter += 1\n end\n\n end\n counter\n end",
"def turn_count\n counter = 0\n @board.each do |index_taken|\n if index_taken == \"X\" || index_taken == \"O\"\n counter += 1\n end\n end\n counter\n end",
"def turn_count(board)\n counter = 0\n board.each do |count|\n if count == \"X\" || count == \"O\"\n counter += 1\n end\nend\ncounter\nend",
"def turn_count(board)\n count = 0\n board.each { |element|\n element == \"X\" || element == \"O\" ? count += 1 : false\n }\n count\nend",
"def turn_count\n turns = 0\n @board.each do |spot|\n if spot==\"X\" || spot==\"O\"\n turns += 1\n end\n end\n return turns\n end",
"def turn_count\n self.cells.count { |cell| cell == \"X\" || cell == \"O\"}\n end",
"def turn_count\n count = 0\n @board.each do |player|\n if player == 'X' || player == 'O'\n count += 1\n end\n end\n return count\n end",
"def whose_turn\n if @turn % 2 == 0\n return \"X\"\n end\n return \"O\"\n end",
"def turn_count\n num_turns = 0\n @board.each do |space|\n if space == \"X\" || space == \"O\"\n num_turns += 1\n end\n end\n return num_turns\n end",
"def turn_count\n\t\tcells.count {|cell| cell == \"X\" || cell == \"O\"}\t\n\tend",
"def turn_count\n counter = 0\n @board.each do|element|\n\tif (element == \"X\") || (element == \"O\")\n \tcounter += 1\n\tend\n end\n return counter\nend",
"def turn_count(board)\n turn = 0\n board.each do |position|\n if position == \"X\" || position == \"O\"\n turn += 1\n end\n end\n return turn\nend",
"def turn_count(board)\n turn = 0\n board.each do |position|\n if position == \"X\" || position == \"O\"\n turn += 1\n end\n end\n return turn\nend",
"def turn_count\n turns = @board.count { |i| i == 'X' || i == 'O' }\n turns\nend",
"def turn_count(board)\n counter = 0\n board.each do |count_turn|\n if count_turn == \"X\" || count_turn == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count\n cells.count { |cell| cell == \"X\" || cell == \"O\" }\n end",
"def turn_count(board)\n turn_counter = 0\n board.each do |spot|\n if spot == \"X\" || spot.upcase == \"O\"\n turn_counter +=1\n end\n end\n return turn_counter\nend",
"def turn_count\n count = 0\n cells.each {|pos| count += 1 if pos == \"X\" || pos == \"O\"}\n count\n end",
"def turn_count\n cells.count {|cell| cell == \"X\" || cell == \"O\"}\n end",
"def turn_count\n counter = 0\n @board.each do|position|\n if position == \"X\" || position == \"O\"\n counter += 1 \n end\n end\n return counter\nend",
"def turn_count(board)\n count=0\n i=0\n while i <= 9\n if board[i] ==\"X\" || board[i] ==\"O\"\n count+=1\n end\n i+=1\n end\n count\nend",
"def turn_count\n cells.count { |char| char == \"X\" || char == \"O\" }\n end",
"def turn_count(board)\ncounter = 0\nboard.each do |board_x|\n if board_x == \"X\" || board_x == \"O\"\ncounter += 1\n end\n end\nreturn counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |turns|\n if turns == \"X\" || turns == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |index|\n if (index == \"X\" or index == \"O\")\n counter+=1\n end\n end\n return counter\nend",
"def turn_count\n cells.count {|value| value == \"X\" || value == \"O\"}\n end",
"def turn_count(board)\n num_of_turns = 0\n board.each do |spot|\n if (spot == 'X' || spot == 'O')\n num_of_turns += 1\n end\n end\n num_of_turns\nend",
"def turn_count\n cells.count{|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count(board)\r\n counter = 0\r\n board.each do |token|\r\n if token == \"X\" || token ==\"O\"\r\n counter +=1\r\n end\r\n end\r\n counter\r\nend",
"def turn_count\r\n cells.count {|cell| cell == \"X\" || cell == \"O\"}\r\n end",
"def winner \n if won? \n turn_count.even? ? \"O\" : \"X\"\n end \n end",
"def turn_count(board)\n counter = 0\n board.each do |move|\n if move == \"X\" || move == \"O\"\n counter += 1\nend\nend\ncounter\nend",
"def turn_count\n count = 0\n @board.each do |token|\n if token.downcase == \"x\" || token.downcase == \"o\"\n count += 1\n end\n end\n count\nend",
"def turn_count(board)\n count = 0\n board.each do |value|\n if value ==\"X\" || value == \"O\"\n count +=1\n end\n end\n return count\nend",
"def turn_count(board)\n counter = 0\n board.each do |element|\n if element == \"O\" || element == \"X\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count(board)\n count = 0\n board.each do |element|\n if element == \"X\" || element == \"O\"\n count += 1\n end\n end\n count\nend",
"def turn_count(board)\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter +=1\n end\n end\n return counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter += 1\n puts \"#{counter}\"\n end\n end\n counter\nend",
"def turn_count\n turns = 0\n @board.each do |position| #can use .count here: board.count{|token| token == \"X\" || token == \"O\"}\n if position == \"X\" || position == \"O\"\n turns += 1\n end\n end\n turns\n end",
"def turn_count(board)\n #this counter keeps track of how many occupied spcaes there are\n counter = 0\n board.each do |turn|\n if turn == \"X\" || turn == \"O\"\n counter += 1\n end\n end\nreturn counter\nend",
"def turn_count(board)\n board.count { |chr| chr ==\"X\" || chr == \"O\"}\nend",
"def turn_count(board)\n counter = 0\n board.each do |token|\n if token == \"X\" || token == \"O\"\n counter += 1\n end\n end\n counter\nend",
"def turn_count(board)\n play_count = 0\n board.each do |play|\n if play == \"X\" || play == \"O\"\n play_count += 1\n end\n end\n play_count\nend",
"def turn_count(board)\n count = 0\n board.each { |element|\n element == \"X\" || element == \"O\" ? count += 1 : nil\n }\n count\nend",
"def turn_count(board)\n count = 0\n board.each do |entry|\n if (entry == \"X\" || entry == \"O\")\n count += 1\n end\n end\n count\nend",
"def turn_count(board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\";\n counter += 1;\n end\n end\n counter\nend",
"def number_of_turns_taken(board)\r\n counter = 0\r\n board.each do |token|\r\n if token == \"X\" || token ==\"O\"\r\n counter +=1\r\n end\r\n end\r\n counter\r\nend",
"def turn_count (board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count(board)\n counter = 0\n board.each do |box|\n if box == \"X\" || box == \"O\"\n counter += 1\nend\nend\n return counter\nend",
"def turn_count(board)\r\n #returns the number of of turns that have been played\r\n counter = 0\r\n board.each do|element|\r\n if (element == \"X\") || (element == \"O\")\r\n counter += 1 \r\n end\r\n end\r\n return counter\r\nend",
"def turn_count(board)\n count=0\n board.each do |pos|\n if(pos==\"X\"||pos==\"O\")\n count+=1\n end\n end\n count\nend",
"def turn_count(board)\n counter = 0\n board.each do |space|\n if space == \"X\" || space == \"O\"\n counter += 1\n end\n end\n return counter\nend",
"def turn_count\n self.cells.count(\"X\") + self.cells.count(\"O\")\n end",
"def turn_count(board)\n count = 0\n board.each do |cell|\n if cell == \"X\" || cell == \"O\"\n count += 1\n end\n end\n count\nend",
"def current_player\n turn_count \n if turn_count%2 != 0 \n \"O\"\n else\n \"X\"\n end\nend",
"def turn_count\n @board.count{|value| (value==\"X\" || value==\"O\")}\n #counter = 0\n #@board.each do |value|\n # if value ==\"X\" || value == \"O\"\n # counter+=1\n # end\n #end\n #counter\n end",
"def turn_count(board)\n counter = 0\n board.each {|char|\n if char == \"O\" || char == \"X\"\n counter += 1\n end\n }\n return counter\nend",
"def current_player\n turn_count == 0 || turn_count % 2 == 0 ? \"X\" : \"O\"\n end",
"def turn_count(board)\n x_counter = 0\n o_counter = 0\n board.each do |spot|\n\n if spot == \"X\"\n x_counter += 1\n\n elsif spot == \"O\"\n o_counter += 1\n end\n end\n\nreturn x_counter + o_counter\nend",
"def turn_count(board)\n count = 0\n board.each do |space|\n if (space == 'X' || space == 'O')\n count += 1\n end\n end\n return count\nend",
"def turn_count(board)\n count= 0\n board.each do |token|\n if token == \"X\" || token == \"O\"\n count +=1\n end\n end\nreturn count\nend",
"def turn_count (board)\n \n turn = 0\n \n board.each do |cell| # cell = element\n if cell == \"X\" || cell == \"O\"\n turn += 1\n else \n turn += 0\n end\n end\n \n return turn\n\nend",
"def turn_count(board)\n turns = 0\n board.each do | space |\n if space == \"X\" || space == \"O\"\n turns += 1\n end\n end\n return turns\nend",
"def turn_count(board)\n turns = 0\n board.each do |spot|\n if spot==\"X\" || spot==\"O\"\n turns += 1\n end\n end\n return turns\nend",
"def turn_count(board)\n count = 0\n board.each do |cell|\n if cell == \"X\" || cell == \"O\"\n count += 1\n end\n end\n return count\nend",
"def turn_count(board)\n count_moves = 0 \n board.each do |check|\n if (check == \"X\" || check == \"O\")\n count_moves += 1 \n end\n end\n return count_moves\nend",
"def current_player(board)\n#takes #turn_count and checks if even, then(?) gives value of X, else(:) it is O\n turn_count(board) % 2 == 0 ? \"X\" : \"O\"\nend",
"def turn_count(board)\n counter = 0;\n board.each do |slot|\n if(slot == \"X\" || slot == \"O\")\n counter += 1;\n end\n end\n return counter;\nend",
"def turn_count #\[email protected]{|token| token == \"X\" || token == \"O\"}\nend",
"def turn_count(board)\n board.count{|element| element == \"X\" || element == \"O\"}\nend",
"def turn_count(board)\n counter = 0\n board.each do |i|\n if i == \"X\" || i == \"O\"\n counter += 1\n end\n end\n puts counter\n return counter\nend",
"def turn_count(board)\n spaces_taken = 0\n board.each do |board_space|\n if board_space == \"X\" || board_space == \"O\"\n spaces_taken += 1 \n end\n end\n return spaces_taken\nend",
"def turn_count\n cells.count{ |space| space ==\"X\" || space ==\"O\" }\n end",
"def turn_count(board)\n board.count {|token| token == \"X\" || token == \"O\"}\n end",
"def turn_count(board)\n\n count = 0\n board.each do |cell|\n if cell == \"X\" || cell == \"O\"\n count += 1\n end\n end\n \n return count\nend",
"def turn_count(board)\n counter = 0 #counter is set to 0 before the for each loop interation begins\n board.each do |turn_count| # the variable turn_count can be called anything, this is a new local variable\n #puts \"Loop number #{counter} gets tuuurn: #{turn_count}\"\n if (turn_count == \"X\") || (turn_count == \"O\") # this if statement is within the loop iteration\n #puts \"Loop number #{counter} gets turn: #{turn_count}\"\n #puts turn_count # i'm outputing the turn_count to see it, but the 'return counter' below is what passes the test\n counter += 1 #adding 1 to the counter for each \"X\" and \"O\" in the board array\n end #end if statement\n end #end for...each loop iteration\n return counter # the counter holds the number of turns, and is what passes the test\nend",
"def turn_count(board)\n count = 0;\n board.each do |square|\n if square == \"X\" || square == \"O\"\n count +=1\n end\n end\n return count #return number of turns that have been played\nend",
"def turn_count(board)\n count=0\n board.each do |position|\n if(position==\"X\"||position==\"O\")\n count+=1\n end\n end\n return count\nend",
"def turn_count(board)\n counter = 0\n board.each do | move |\n if move == \"X\" || move == \"O\"\n puts counter += 1\n end\n end\n counter #This should be the number of turns\nend",
"def other_turn\n\t\t@turn == \"x\" ? \"o\" : \"x\"\n\tend",
"def turn_count(board)\n count = 0\n board.each do |occupied|\n if occupied == \"X\" || occupied == \"O\"\n #if count is =< to 9\n count = count + 1\n end\n end\n return count\nend",
"def turn_count(board)\n count = 0\n board.each do |index|\n index == \"X\" || index == \"O\" ? count += 1 : nil\n end\n return count\n end",
"def turn_count(board)\n board.count{|token| token == \"X\" || token == \"O\"}\nend",
"def current_player(board)\nif turn_count(board) % 2 == 0\n \"X\"\nelsif turn_count(board) % 2 == 1\n \"O\"\n end\nend",
"def change_turn\n @turn = @turn >= 'X' ? 'O' : 'X'\n @turn_played += 1\n end",
"def current_player\n turn_count.even? ? \"X\" : \"O\"\n end",
"def turn_count(board)\n counter = 0\n board.each do |board_element|\n if board_element == \"X\" || board_element == \"O\"\n counter += 1\n # puts \"Board element is: #{board_element}. Occupied elements are #{counter}\"\n end\n end\n return counter\nend"
] | [
"0.79763603",
"0.79566556",
"0.79362917",
"0.7906085",
"0.790215",
"0.7877868",
"0.7849504",
"0.78430694",
"0.7822989",
"0.77852035",
"0.7778221",
"0.7773456",
"0.7757436",
"0.77327853",
"0.7729393",
"0.7728167",
"0.7725383",
"0.7718589",
"0.77140474",
"0.77095824",
"0.7700333",
"0.76946294",
"0.76903117",
"0.76624596",
"0.7649939",
"0.76400524",
"0.76400524",
"0.7628539",
"0.7626263",
"0.76195467",
"0.76091975",
"0.75926274",
"0.7590808",
"0.7580632",
"0.75797933",
"0.7563784",
"0.75619936",
"0.75608474",
"0.75498444",
"0.75485176",
"0.7545603",
"0.75452477",
"0.7523719",
"0.7519825",
"0.7519412",
"0.75088286",
"0.75064665",
"0.75025535",
"0.74962485",
"0.7495914",
"0.7492291",
"0.74667525",
"0.7455381",
"0.7451395",
"0.7448461",
"0.7446886",
"0.74443525",
"0.74396133",
"0.7436347",
"0.74360764",
"0.743506",
"0.7428286",
"0.74247116",
"0.74109656",
"0.74089783",
"0.74032605",
"0.73854446",
"0.73793757",
"0.7377165",
"0.7375278",
"0.73648435",
"0.7351672",
"0.7348502",
"0.7345658",
"0.73409516",
"0.7339688",
"0.7326766",
"0.7321766",
"0.7310069",
"0.7307227",
"0.7306333",
"0.72910774",
"0.72865623",
"0.72821397",
"0.72793",
"0.7271273",
"0.7267745",
"0.72599167",
"0.7253341",
"0.72174054",
"0.72153836",
"0.7202506",
"0.7200491",
"0.7197043",
"0.7181756",
"0.7178665",
"0.71714973",
"0.7163",
"0.7155661",
"0.7155626",
"0.71150804"
] | 0.0 | -1 |
begining of game status checks for win combinations and prints winning combo, or nil | def won?(board)
WIN_COMBINATIONS.each do |combo|
if (board[combo[0]] == board[combo[1]] && board[combo[0]] == board[combo[2]] && board[combo[0]] != " " && board[combo[0]] != "" && !board[combo[0]].nil?)
return combo
break
end
end
return false
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_game_status\n # create all winning combinations in a variable using an array\n winning_combos = [[@board[0],@board[1],@board[2]], [@board[3],@board[4],@board[5]], [@board[6],@board[7],@board[8]], [@board[0],@board[3],@board[6]], [@board[1],@board[4],@board[7]], [@board[2],@board[5],@board[8]], [@board[0],@board[4],@board[8]], [@board[2],@board[4],@board[6]] ]\n # if the winning combinations include all \"X\"'s then you won\n if winning_combos.include? ([@symbol, @symbol, @symbol])\n display_board\n puts \"Winner!\"\n exit\n # if the winning combinations include all \"O\"'s the computer won.\n elsif winning_combos.include? ([@computer_symbol, @computer_symbol, @computer_symbol])\n display_board\n puts \"You lose. Better luck next time!\"\n exit\n # check if the game is a tie/draw\n elsif @board.all? {|i| i == \"X\" || i == \"O\"}\n display_board\n puts \"It's a draw. Try again.\"\n exit\n else\n # if none of these then continue playing the game\n play_game\n end\n end",
"def won?\n # for each win_combo in WIN_COMBINATIONS\n WIN_COMBINATIONS.each do |win_combo|\n # win_combination is a 3 element array of indexes that compose a win, eg. [0,1,2]\n # grab each index from the win_combo that composes a win.\n win_index_1 = win_combo[0]\n win_index_2 = win_combo[1]\n win_index_3 = win_combo[2]\n # If/else that declares a winner if all three spots in a winning array have\n # either an \"X\" or an \"O\", respectively.\n if @board[win_index_1] == \"X\" && @board[win_index_2] == \"X\" && @board[win_index_3] == \"X\"\n puts \"Congratulations X!\"\n puts \"You won!\"\n return win_combo\n elsif @board[win_index_1] == \"O\" && @board[win_index_2] == \"O\" && @board[win_index_3] == \"O\"\n puts \"Congratulations O!\"\n puts \"You won!\"\n return win_combo\n end\n end\n return false\n end",
"def win_test\n \t# Create a hash from entries where the value matches player @letter\n\tpositions_hash = $board.select { |key, value| value == @letter }\n\t# Now make an array of the key values. We will compare this against \n\t# the winning_combos\n\tpositions_array = positions_hash.keys\n\t\t# Did the current move win the game?\n\t\t$winning_combos.each { \n\t\t\t|x| if x == positions_array\n\t\t\t\tputs \"#{@name} WINS!\"\n\t\t\t\t$game_end = true\n\t\t\t\treturn\n\t\t\t\tend\n\t\t\t}\n\nend",
"def check_game_status (some_array) \n include StrategyTools\n \n currentboard_array = view_currentboard(some_array)\n rows = currentboard_array[0]\n cols = currentboard_array[1]\n diag1 = currentboard_array[2]\n diag2 = currentboard_array[3]\n\t\n\t\n check = 0 \n \n #user win?\n if (sum_array(rows[0])) == 3 || (sum_array(rows[1])) == 3 || (sum_array(rows[2])) == 3 then check = 1 \n\telsif (sum_array(cols[0])) == 3 || (sum_array(cols[1])) == 3 || (sum_array(cols[2])) == 3 then check = 1 \n\telsif ((sum_array(diag1)) == 3) then check = 1 \n\telsif ((sum_array(diag2)) == 3) then check = 1\n \n\n #computer win?\n elsif (sum_array(rows[0])) == 30 || (sum_array(rows[1])) == 30 || (sum_array(rows[2])) == 30 then check = 10 \n elsif (sum_array(cols[0])) == 30 || (sum_array(cols[1])) == 30 || (sum_array(cols[2])) == 30 then check = 10 \n elsif ((sum_array(diag1)) == 30) then check = 10 \n elsif ((sum_array(diag2)) == 30) then check = 10 \n \n\t\n\t#full board/no win\n\telsif sum_array_of_arrays(some_array) >= 45 then check = 2\n end\n \n check \n \n end",
"def check_win\n\t\t\tif win\n\t\t\t\tputs \"\\n You win!\" \n\t\t\telse\n\t\t\t\t# shows how many turns remain\n\t\t\t\tputs \"\\n You have #{TURNS - @turns} turns left\"\n\t\t\tend\n\t\tend",
"def won? # shows winning combination\n WIN_COMBINATIONS.detect do |win_combo|\n if (@board[win_combo[0]]) == \"X\" && (@board[win_combo[1]]) == \"X\" && (@board[win_combo[2]]) == \"X\"\n return win_combo\n elsif (@board[win_combo[0]]) == \"O\" && (@board[win_combo[1]]) == \"O\" && (@board[win_combo[2]]) == \"O\"\n return win_combo\n end\n false\n end\nend",
"def winner\n no_combinations = true\n WIN_COMBINATIONS.each do |combination|\n if combination1 = @board[combination[0]] == \"X\" && @board[combination[1]] == \"X\" && @board[combination[2]] == \"X\"\n no_combinations = false\n return \"X\"\n elsif combination2 = @board[combination[0]] == \"O\" && @board[combination[1]] == \"O\" && @board[combination[2]] == \"O\"\n no_combinations = false\n return \"O\"\n end\n end\n if no_combinations == true\n return nil\n end\n end",
"def show_round_status\n puts \"=================================================\"\n # Do not display guess result before first guess, or on win/loss screen\n unless @letters_guessed.empty? || @continuing_saved_game == true\n puts (@word_array.include?(@letters_guessed.last) ? \"\\nMATCH!\" : \"\\nMISS!\")\n end\n @continuing_saved_game = false # Set to true during load_game.\n if @round_won\n puts \"\\nYou Won! Way to Go!\\n \"\n puts %Q(You solved the word: \"#{@word_array_player.join}\")\n show_score\n elsif @round_over\n puts \"\\nYou Lost! Better luck next time...\\n \"\n puts %Q(The word was: \"#{@word_array.join}\")\n show_score\n else\n puts \"\\n#{@player}, here's your clue so far:\\n \"\n puts @word_array_player.join(\" \")\n puts \"\\nNumber of incorrect guesses left: #{@errors_left}\"\n end\n end",
"def winner\n $the_win_comb = { flash_straight: flash_straight, for_of_kind: four_of_kind, full_house: full_house,\n flush: flush, straight: straight, three: three, two_pair: two_pair,\n one_pair: one_pair, high_card: high_card }\n puts \"\\n The highest winner combinations and cards are - \"\n $the_win_comb.each { |comb, ans| return puts comb.upcase, $the_win_comb[comb], ' ' unless ans.nil?}\n end",
"def check_for_win(game)\n return nil if game.turns.size < 5 \n\n xs = game.turns.where(mark: 'X').map {|turn| turn.board_index }\n os = game.turns.where(mark: 'O').map {|turn| turn.board_index }\n\n @@win_conditions.each do |win|\n # Check if xs or os contain indices combo that meet win condition\n if (win-xs).empty?\n return [\"X\", win.join(' ')]\n elsif (win-os).empty?\n return [\"O\",win.join(' ')]\n end\n end\n\n if game.turns.size > 8\n return [\"TIE\",\"\"]\n else\n return nil\n end\n end",
"def win_or_lose\n if game_data.guesses_remaining.zero?\n puts File.read('./views/you_dead')\n puts File.read('./views/dead')\n elsif game_data.letters_left_to_guess == []\n puts File.read('./views/winscreen')\n else\n # allows us to break recursion if we are testing\n @test_cond == false ? Turn.new(game_data) : true\n end\n end",
"def play\n until over?\n turn\n end\n\n if draw?\n puts \"Cat's Game!\"\n elsif WIN_COMBINATIONS.include?(won?)\n puts \"Congratulations #{winner}!\"\n end\nend",
"def determine_status\n if opponent_board.present? and opponent_board.all_ships_are_sunk?\n \"You Win! Congratulations!\"\n elsif player_board.present? and player_board.all_ships_are_sunk?\n \"You Lose! Better luck next time...\"\n end\n end",
"def won?\n WIN_COMBINATIONS.detect { |combo|\n @board.cells[combo[0]] == @board.cells[combo[1]] &&\n @board.cells[combo[0]] == @board.cells[combo[2]] &&\n @board.taken?(combo[0] + 1)\n }\n # x = \"X\";\n # o = \"O\";\n #\n # WIN_COMBINATIONS.each do |win_combination|\n # win_index_1 = win_combination[0];\n # win_index_2 = win_combination[1];\n # win_index_3 = win_combination[2];\n #\n # position_1 = @board.cells[win_index_1];\n # position_2 = @board.cells[win_index_2];\n # position_3 = @board.cells[win_index_3];\n #\n # if ((position_1 == x && position_2 == x && position_3 == x) ||\n # (position_1 == o && position_2 == o && position_3 == o))\n # return win_combination;\n # else\n # false;\n # end\n # end\n # false; #explicitly tell ruby to return false if we've cycled through the board and no win combinations can be found\n end",
"def won?\n\n WIN_COMBINATIONS.each do |win_combination|\n # win_combination is a 3 element array of indexes that compose a win, [0,1,2]\n # grab each index from the win_combination that composes a win.\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n position_1 = @board.cells[win_index_1] # load the value of the board at win_index_1\n position_2 = @board.cells[win_index_2] # load the value of the board at win_index_2\n position_3 = @board.cells[win_index_3] # load the value of the board at win_index_3\n\n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n return win_combination # return the win_combination indexes that won.\n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n return win_combination\n end\n end\n false\n end",
"def win_game(board)\n final_board = \" #{board[0]} | #{board[1]} | #{board[2]}\\n-----------\\n #{board[3]} | #{board[4]} | #{board[5]}\\n-----------\\n #{board[6]} | #{board[7]} | #{board[8]}\"\n if board[0] == board[1] && board[1] == board[2]\n puts final_board\n puts \"CONGRATULATIONS #{board[0]} WINS\"\n exit\n elsif board[3] == board[4] && board[4] == board[5]\n puts final_board\n puts \"CONGRATULATIONS #{board[3]} WINS\"\n exit\n elsif board[6] == board[7] && board[7] == board[8]\n puts final_board\n puts \"CONGRATULATIONS #{board[6]} WINS\"\n exit \n elsif board[0] == board[3] && board[3] == board[6]\n puts final_board\n puts \"CONGRATULATIONS #{board[0]} WINS\"\n exit \n elsif board[1] == board[4] && board[4] == board[7]\n puts final_board\n puts \"CONGRATULATIONS #{board[1]} WINS\"\n exit \n elsif board[2] == board[5] && board[5] == board[8]\n puts final_board\n puts \"CONGRATULATIONS #{board[2]} WINS\"\n exit\n elsif board[0] == board[4] && board[4] == board[8]\n puts final_board\n puts \"CONGRATULATIONS #{board[0]} WINS\"\n exit\n elsif board[0] == board[4] && board[4] == board[8]\n puts final_board\n puts \"CONGRATULATIONS #{board[0]} WINS\"\n exit\n elsif board[2] == board[4] && board[4] == board[6]\n puts final_board\n puts \"CONGRATULATIONS #{board[2]} WINS\"\n exit \n end\nend",
"def won?\n the_win_combination = false\n WIN_COMBINATIONS.each do |win_combination|\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n position_1 = @board[win_index_1]\n position_2 = @board[win_index_2]\n position_3 = @board[win_index_3]\n\n if (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n the_win_combination = win_combination\n break\n end\n end\n the_win_combination\n end",
"def check_for_winner\n #define what wins the game\n win_combinations = [ [0,3,6], [0,4,8], [0,1,2], [1,4,7], [2,4,6], [2,5,8], [3,4,5], [6,7,8] ]\n #if sym fills any of these combos of 3, that player wins else, game is tie..play again?\n for i in 0..7\n win_combinations.each do |x| \n if (@board[x[0]] == @board[x[1]] && @board[x[0]] == @board[x[2]] && @board[x[0]] != \"\" && @board[x[1]] != \"\" && @board[x[2]] != \"\")\n if @board[x[0]] == PLAYER1_SYM\n puts \"Player 1 Wins!!!!!!\"\n else\n puts \"Player 2 Wins!!!!!!\"\n end\n generate_board\n abort(\"game over\")\n elsif unless @board.include? \"\" #check for tie once board is ful\n abort(\"Game is a tie\")\n end\n else\n end\n end\n end\n end",
"def status\n if @game_mode == 2\n\t if @correct_pos == 4\n\t\t@winner = true\n\t\tputs \"The computer guessed correctly! You lose!\"\n\t else\n\t\tputs \"The computer's guess: #{@guess}\"\n\t\tputs \"Number in correct position: #{@correct_pos}\"\n\t\tputs \"Correct number, but wrong position: #{@correct_num}\"\n\t \t\n if @turns_left > 1\n\t\t puts \"The computer has #{@turns_left} turns remaining.\"\n puts \"\"\n\t\telsif @turns_left == 1\n\t\t puts \"The computer has #{@turns_left} turn remaining.\"\n puts \"\"\n\t\telsif @turns_left == 0\n\t\t puts \"GAME OVER!\"\n\t\t puts \"YOU WIN!\"\n\t\t\t\n\t\tend\n\t end\n\telse\n\t if @correct_pos == 4\n\t\t@winner = true\n\t\tputs \"YOU WIN! CONGRATULATIONS!\"\n\t else\n\t\tputs \"Your guess: #{@guess}\"\n\t\tputs \"Number in correct position: #{@correct_pos}\"\n\t\tputs \"Correct number, but wrong position: #{@correct_num}\"\n\t\tif @turns_left > 1\n\t\t puts \"You have #{@turns_left} turns remaining.\"\n\t\telsif @turns_left == 1\n\t\t puts \"You have #{@turns_left} turn remaining.\"\n\t\telsif @turns_left == 0\n\t\t puts \"GAME OVER!\"\n\t\t puts \"The correct answer was: #{@solution}\"\n\t\tend\n\t end\n\tend\n end",
"def won?(board)\n # cycle through WIN_COMBINATIONS\n WIN_COMBINATIONS.detect { |winning_combo|\n # print win_index\n # print '\\n'\n position_taken?(board,winning_combo[0]) &&\n position_taken?(board,winning_combo[1]) &&\n position_taken?(board,winning_combo[2]) &&\n board[winning_combo[0]] == board[winning_combo[1]] &&\n board[winning_combo[1]] == board[winning_combo[2]]\n }\nend",
"def check_winner\n if win_state == CHECK\n if players[0].get_hand_score >= players[1].get_hand_score\n self.win_state = LOSS\n else\n self.win_state = WIN\n end\n end\n\n if win_state == WIN\n self.wins = wins + 1 \n puts \"Good win! You're now at #{wins} wins and #{losses}.\"\n else\n self.losses = losses + 1\n puts \"Better luck next time. You're now at #{wins} wins and #{losses} losses.\"\n end\n end",
"def output_results(x_won, o_won, win, round, mark, move)\r\n tab(5, \"Round #{round}: #{mark} selected #{move}\", \"-\" * 31)\r\n if x_won == true\r\n tab(7, \"Player 1 (X) won!\", \"\\n\")\r\n tab(3, \"Winning moves: #{win}\", \"-\" * 31)\r\n elsif o_won == true\r\n tab(7, \"Player 2 (O) won!\", \"\\n\")\r\n tab(3, \"Winning moves: #{win}\", \"-\" * 31)\r\n else\r\n tab(9, \"It was a tie!\", \"-\" * 31)\r\n end\r\n end",
"def determine_win\n\t\t@win_combos.each do |combo|\n\t\t\tp1 = (@p1_spaces & combo).length\n\t\t\tp2 = (@p2_spaces & combo).length\n\n\t\t\tif p1 == 3\n\t\t\t\treturn 1\n\t\t\t\tp1.games_won += 1\n\t\t\telsif p2 == 3\n\t\t\t\treturn 2\n\t\t\t\tp2.games_won += 1\n\t\t\tend\n\t\tend\n\t\t0\n\tend",
"def won?(board)\nany_return = WIN_COMBINATIONS.any? do |combo|\n board[combo[0]] == \"X\" && board[combo[1]] == \"X\" && board[combo[2]] == \"X\" ||\n board[combo[0]] == \"O\" && board[combo[1]] == \"O\" && board[combo[2]] == \"O\"\nend\nselect_return = WIN_COMBINATIONS.select do |combo|\n board[combo[0]] == \"X\" && board[combo[1]] == \"X\" && board[combo[2]] == \"X\" ||\n board[combo[0]] == \"O\" && board[combo[1]] == \"O\" && board[combo[2]] == \"O\"\nend\n if any_return == false\n any_return\n elsif select_return != nil\n win_return = select_return[0]\n end\nend",
"def won?\ntokens = [\"X\", \"O\"]\nwon = false\n@x_win = false\n@o_win = false\nwinning_combo = []\n\nWIN_COMBINATIONS.each do |combination|\n @x_win = combination.all?{|index| @board[index] == tokens[0]} if true\n @o_win = combination.all?{|index| @board[index] == tokens[1]} if true\n if @x_win || @o_win\n won = true\n winning_combo = combination\n end\nend\n\nif won #what should we return\n winning_combo\nelse\n false\nend\nend",
"def check_outcome(player)\n case @board.status\n when 1\n puts \"*** #{player.name} Won Congratulations! ***\"\n 1\n when 0\n puts \"*** That's a tie ***\"\n 0\n else\n -1\n end\n end",
"def won?\n WIN_COMBINATIONS.find do |winning_combo|\n winning_index_1 = winning_combo[0]\n winning_index_2 = winning_combo[1]\n winning_index_3 = winning_combo[2]\n \n position_1 = @board[winning_index_1]\n position_2 = @board[winning_index_2]\n position_3 = @board[winning_index_3]\n \n (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") || (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n end\n end",
"def win\n\t\tputs \"Player #{@myIndex} made a correct accusation and has won the game!\"\n\tend",
"def main_game\n p1_wins = 0\n p2_wins = 0\n puts \"Let's play Rock-Paper-Scissors!\"\n games = how_many_games\n best_of(games)\n\n until p1_wins == games || p2_wins == games\n winner = one_round\n display_winner(winner)\n p1_wins += track_p1_wins(winner)\n p2_wins += track_p2_wins(winner)\n end\n\n overall_winner = overall_winner?(p1_wins, p2_wins)\n display_overall_winner(overall_winner)\nend",
"def game_over?(player_input, current_move)\n\tif player_input.combination(3).map.any?{|i| WINNER}\n\t\tputs \"Congrats#{player_input}, your a winner!\"\n\telsif current_move == 9\t\n\t\tputs \"It's a draw, suckers!\"\n\tend\nend",
"def won?\n\n WIN_COMBINATIONS.find do |win_combination|\n # puts \"This is win combination #{win_combination}\"\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n position_1 = @board[win_index_1]\n position_2 = @board[win_index_2]\n position_3 = @board[win_index_3]\n\n position_1 == position_2 && position_2 == position_3 && position_taken?(win_index_1)\n end\n end",
"def won?(board)\n WIN_COMBINATIONS.any? do |combo|\n if combo.all? do |i|\n position_taken_x?(board, i)\n end\n return combo\n puts \"Congratulations, X wins!\"\n break\n elsif combo.all? do |i|\n position_taken_o?(board, i)\n end\n return combo\n puts \"Congratulations, O wins!\"\n break\n else\n false\n end\n end\n end",
"def win_game\n @win.each do |m|\n if @board[m[0]].strip == @board[m[1]] && @board[m[1]] == @board[m[2]]\n @winner = true\n end\n end\n @winner\n end",
"def won?(board)\n if board == [\" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \"]\n false\n elsif\n WIN_COMBINATIONS.each do |combination|\n if board[0] == \"X\" && board[1] == \"X\" && board[2] == \"X\"\n return WIN_COMBINATIONS[0]\n elsif board[0] == \"O\" && board[1] == \"O\" && board[2] == \"O\"\n return WIN_COMBINATIONS[0]\n elsif board[3] == \"X\" && board[4] == \"X\" && board[5] == \"X\"\n return WIN_COMBINATIONS[1]\n elsif board[3] == \"O\" && board[4] == \"O\" && board[5] == \"O\"\n return WIN_COMBINATIONS[1]\n elsif board[6] == \"X\" && board[7] == \"X\" && board[8] == \"X\"\n return WIN_COMBINATIONS[2]\n elsif board[6] == \"O\" && board[7] == \"O\" && board[8] == \"O\"\n return WIN_COMBINATIONS[2]\n elsif board[0] == \"X\" && board[3] == \"X\" && board[6] == \"X\"\n return WIN_COMBINATIONS[3]\n elsif board[0] == \"O\" && board[3] == \"O\" && board[6] == \"O\"\n return WIN_COMBINATIONS[3]\n elsif board[1] == \"X\" && board[4] == \"X\" && board[7] == \"X\"\n return WIN_COMBINATIONS[4]\n elsif board[1] == \"O\" && board[4] == \"O\" && board[7] == \"O\"\n return WIN_COMBINATIONS[4]\n elsif board[2] == \"X\" && board[5] == \"X\" && board[8] == \"X\"\n return WIN_COMBINATIONS[5]\n elsif board[2] == \"O\" && board[5] == \"O\" && board[8] == \"O\"\n return WIN_COMBINATIONS[5]\n elsif board[0] == \"X\" && board[4] == \"X\" && board[8] == \"X\"\n return WIN_COMBINATIONS[6]\n elsif board[0] == \"O\" && board[4] == \"O\" && board[8] == \"O\"\n return WIN_COMBINATIONS[6]\n elsif board[2] == \"X\" && board[4] == \"X\" && board[6] == \"X\"\n return WIN_COMBINATIONS[7]\n elsif board[2] == \"O\" && board[4] == \"O\" && board[6] == \"O\"\n return WIN_COMBINATIONS[7]\n else\n return false\n end\n end\n else\n false\n end\nend",
"def won?\n WIN_COMBINATIONS.detect do |combo|\n if combo.all? {|c| @board.cells[c] == \"X\"}\n @winner = \"X\"\n return combo\n elsif combo.all?{|c| @board.cells[c] == \"O\"}\n @winner = \"O\"\n return combo\n end\n end\n nil\n end",
"def won?(board)\nwin_combination = WIN_COMBINATIONS\n\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n win_index_4 = win_combination[3]\n win_index_5 = win_combination[4]\n win_index_6 = win_combination[5]\n win_index_7 = win_combination[6]\n win_index_8 = win_combination[7]\n\n position_1 = board[0] # load the value of the board at win_index_1\n position_2 = board[1] # load the value of the board at win_index_2\n position_3 = board[2] # load the value of the board at win_index_3\n position_4 = board[3] # load the value of the board at win_index_4\n position_5 = board[4] # load the value of the board at win_index_5\n position_6 = board[5] # load the value of the board at win_index_6\n position_7 = board[6] # load the value of the board at win_index_7\n position_8 = board[7] # load the value of the board at win_index_8\n position_9 = board[8] # load the value of the board at win_index_9\n\n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n return win_combination[0] # return the win_combination indexes that won.\n elsif position_4 == \"X\" && position_5 == \"X\" && position_6 == \"X\"\n return win_combination[1] # return the win_combination indexes that won.\n elsif position_7 == \"X\" && position_8 == \"X\" && position_9 == \"X\"\n return win_combination[2] # return the win_combination indexes that won.\n elsif position_1 == \"X\" && position_4 == \"X\" && position_7 == \"X\"\n return win_combination[3] # return the win_combination indexes that won.\n elsif position_2 == \"X\" && position_5 == \"X\" && position_8 == \"X\"\n return win_combination[4] # return the win_combination indexes that won.\n elsif position_3 == \"X\" && position_6 == \"X\" && position_9 == \"X\"\n return win_combination[5] # return the win_combination indexes that won.\n elsif position_7 == \"X\" && position_5 == \"X\" && position_3 == \"X\"\n return win_combination[6] # return the win_combination indexes that won.\n elsif position_1 == \"X\" && position_5 == \"X\" && position_9 == \"X\"\n return win_combination[7] # return the win_combination indexes that won.\n \n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n return win_combination[0] # return the win_combination indexes that won.\n elsif position_4 == \"O\" && position_5 == \"O\" && position_6 == \"O\"\n return win_combination[1] # return the win_combination indexes that won.\n elsif position_7 == \"O\" && position_8 == \"O\" && position_9 == \"O\"\n return win_combination[2] # return the win_combination indexes that won.\n elsif position_1 == \"O\" && position_4 == \"O\" && position_7 == \"O\"\n return win_combination[3] # return the win_combination indexes that won.\n elsif position_2 == \"O\" && position_5 == \"O\" && position_8 == \"O\"\n return win_combination[4] # return the win_combination indexes that won.\n elsif position_3 == \"O\" && position_6 == \"O\" && position_9 == \"O\"\n return win_combination[5] # return the win_combination indexes that won.\n elsif position_7 == \"O\" && position_5 == \"O\" && position_3 == \"O\"\n return win_combination[6] # return the win_combination indexes that won.\n elsif position_1 == \"O\" && position_5 == \"O\" && position_9 == \"O\"\n return win_combination[7] # return the win_combination indexes that won.\n else\n false\n end\nend",
"def verify_winner(opponent_board)\n if opponent_board.ships.all?(&:sunk?)\n @board_turn.player.set_win\n\n if @best_of3 && @boards.map(&:player).any? { |player| player.wins > 1 }\n puts \"*******************************************************\".green\n puts \"Player #{@board_turn.player.name} has won best of 3!!!!\".green\n puts \"********************************************************\".green\n elsif @best_of3 && @boards.map(&:player).any? { |player| player.wins <= 1 }\n puts \"*********************************************\".green\n puts \"Player #{@board_turn.player.name} has won a game of 3!!!!\".green\n puts \"*********************************************\".green\n else\n puts \"*********************************************\".green\n puts \"Player #{@board_turn.player.name} has won a single game!!!!\".green\n puts \"*********************************************\".green\n end\n\n if @random && @best_of3 && @boards.map(&:player).all? { |player| player.wins < 2 }\n print \"#{@board_turn.player.name} wins, enter for next match?: \".cyan\n $stdin.gets.chomp\n\n print \"\\e[H\\e[2J\"\n :new_game\n elsif @random && @boards.map(&:player).any? { |player| player.wins > 1 }\n :finished_game_of3\n elsif @random\n ask_new_game\n else\n :finished\n end\n else\n next_turn\n :hitted\n end\n end",
"def won?(board)\n WIN_COMBINATIONS.each {|win_combo|\n index_0 = win_combo[0]\n index_1 = win_combo[1]\n index_2 = win_combo[2]\n\n position_1 = board[index_0]\n position_2 = board[index_1]\n position_3 = board[index_2]\n\n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n final_winner = \"X\"\n return win_combo\n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n final_winner = \"O\"\n return win_combo\n end\n }\n return false\nend",
"def won?(board)\n # for each win_combo in WIN_COMBINATIONS\n WIN_COMBINATIONS.each do |win_combo|\n # win_combination is a 3 element array of indexes that compose a win, eg. [0,1,2]\n # grab each index from the win_combo that composes a win.\n win_index_1 = win_combo[0]\n win_index_2 = win_combo[1]\n win_index_3 = win_combo[2]\n # If/else that declares a winner if all three spots in a winning array have\n # either an \"X\" or an \"O\", respectively.\n if board[win_index_1] == \"X\" && board[win_index_2] == \"X\" && board[win_index_3] == \"X\"\n return win_combo\n elsif board[win_index_1] == \"O\" && board[win_index_2] == \"O\" && board[win_index_3] == \"O\"\n return win_combo\n end\n end\n return false\nend",
"def won?\n WIN_COMBINATIONS.any? do |win_combo|\n win_index_1 = win_combo[0]\n win_index_2 = win_combo[1]\n win_index_3 = win_combo[2]\n\n position_1 = @board[win_index_1]\n position_2 = @board[win_index_2]\n position_3 = @board[win_index_3]\n\n if position_taken?(win_index_1) && position_1 == position_2 && position_2 == position_3\n #binding.pry\n return win_combo\n end\n end\n end",
"def won?\n \n # Iterates through WIN_COMBINATIONS and finds first matching win_combination and returns the winning array.\n WIN_COMBINATIONS.detect do |win_combination|\n \n # Each 'win_index' returns the first, second, and third elements of each winning combo array.\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n \n # Each 'position' uses the indices from the winning combos and applies them to the 'board' array.\n position_1 = @board[win_index_1]\n position_2 = @board[win_index_2]\n position_3 = @board[win_index_3]\n \n # Takes first win_combination and checks to see if they are all \"X\"'s or \"O\"'s and that the string is not empty.\n position_1 == position_2 && position_2 == position_3 && position_taken?(win_index_1)\n end\n end",
"def won?(board)\n WIN_COMBINATIONS.detect do |win_combination|\n win_index_1=win_combination[0]\n win_index_2=win_combination[1]\n win_index_3=win_combination[2]\n\n if board[win_index_1]==\"X\" && board[win_index_2]==\"X\" && board[win_index_3]==\"X\"\n #return win_combination\n win_combination=win_combination\n #puts\"#{win_combination}\"\n elsif board[win_index_1]==\"O\" && board[win_index_2]==\"O\" && board[win_index_3]==\"O\"\n #return win_combination\n win_combination=win_combination\n #puts\"#{win_combination}\"\n #return win_combination\n else false#win_combination=false\n end\n\n end\n#win_combination=win_combination\n#return win_combination\n#puts\"#{win_combination}\"\nend",
"def winning?(game)\n if game.word == game.progress\n puts \"You won! Yaaaaay!!\"\n exit\n end\nend",
"def won?(board)\nempty_board = board.all? {|empty| empty == \" \"}\ndraw = board.all? {|token| token == \"X\" || token == \"O\"}\nWIN_COMBINATIONS.any? do |win_combo|\n if win_combo.all? {|index| board[index] ==\"X\" } || win_combo.all? {|index| board[index] ==\"O\"}\n return win_combo\n else empty_board || draw\n false\n end\n end\nend",
"def won?(board)\nempty_board = board.all? {|empty| empty == \" \"}\ndraw = board.all? {|token| token == \"X\" || token == \"O\"}\nWIN_COMBINATIONS.any? do |win_combo|\n if win_combo.all? {|index| board[index] ==\"X\" } || win_combo.all? {|index| board[index] ==\"O\"}\n return win_combo\n else empty_board || draw\n false\n end\n end\nend",
"def game_over(result, turns, game_word)\n system('cls')\n if result == 'WIN'\n puts '***************************************************************'\n puts '* YOU WON!! *'\n puts '***************************************************************'\n puts ''\n puts ' The word was: ' + game_word\n puts ''\n puts ' You guessed it in ' + turns.to_s + ' turns!'\n puts ''\n puts ''\n puts 'Press \"R\" to Play Again or \"Q\" to Quit!'\n puts ''\n print 'Option:'\n else\n puts '***************************************************************'\n puts '* YOU LOSE!! *'\n puts '***************************************************************'\n puts ''\n puts ' The word was: ' + game_word\n puts ''\n puts ''\n puts 'Press \"P\" to Play Again or \"Q\" to Quit!'\n puts ''\n print 'Option:'\n end\n end",
"def won?(board)\n win_combo = nil\n WIN_COMBINATIONS.each do |win_combination|\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n token1 = board[win_combination[0]]\n token2 = board[win_combination[1]]\n token3 = board[win_combination[2]]\n\n if token1 == \"X\" && token2 == \"X\" && token3 == \"X\"\n win_combo = win_combination\n elsif token1 == \"O\" && token2 == \"O\" && token3 == \"O\"\n win_combo = win_combination\n end\n end\n win_combo\nend",
"def determine_winner\n if @current_moves[0] == @current_moves[1]\n \t\tputs \"We have a tie!\"\n \telsif ((@current_moves[0] == \"Rock\") && (@current_moves[1] == \"Scissors\")) \n \t\tputs \"#{player_1.name} wins - #{@current_moves[0]} crushes #{@current_moves[1]}\"\n @winner = @player_1\n player_1.games_won\n \telsif ((@current_moves[0] == \"Scissors\") && (@current_moves[1] == \"Paper\")) \n \t\tputs \"#{player_1.name} wins - #{@current_moves[0]} cuts #{@current_moves[1]}\"\n @winner = @player_1\n player_1.games_won\n \telsif ((@current_moves[0] == \"Paper\") && (@current_moves[1] == \"Rock\"))\n \t\tputs \"#{player_1.name} wins - #{@current_moves[0]} covers #{@current_moves[1]}\"\n @winner = @player_1\n player_1.games_won\n \telse\n \t\tputs \"#{player_2.name} wins - #{@current_moves[1]} beats #{@current_moves[0]}\"\n @winner = @player_2\n player_2.games_won\n \tend\n end",
"def comb_to_win\n s = Card_on_table.new\n g =Combinations.new(s.open_card)\n g.winner_comb\n print \"\\n Give me name of combinations you wonna see on the table.\\n You can choose of: \"\n $the_win_comb.each{|name,m| print name, ' '}\n comb = gets.chomp.to_sym\n puts \"Wait! I am working, trying to find combination : #{comb}!\"\n itr = 0\n time_1 = Time.now\n find_comb = $the_win_comb[comb]\n while find_comb == nil do\n itr+=1\n s = Card_on_table.new\n g =Combinations.new(s.open_card)\n g.winner_comb\n find_comb = $the_win_comb[comb]\n time_2 = Time.now\n end\n print 'Number of itterations - ',itr, ' Time of work,s - ',time_2-time_1\nend",
"def possible_any_win # => winning combo\n opponent_token = self.token == \"X\" ? \"O\" : \"X\"\n Game.win_combos.find { |combo|\n tokens = combo.map {|spot| token_at(spot)}\n (tokens.count{|s| s==\"X\" }==2 || tokens.count{|s| s==\"O\"}==2) &&\n open_spot(combo)\n }\n end",
"def win_actions\n @i.cls\n @i.show_balance(@user)\n @i.show_cards(@open, @user, @croupier)\n @i.winner_msg(@user, @croupier, @winner) if @winner == @user || @winner == @croupier\n @i.winner_msg(@user, @croupier, @draw) if @winner == @draw\n\n # balance\n @winner.balance += @bank if @winner == @user || @winner == @croupier\n if @winner == @draw\n @user.balance += 10\n @croupier.balance += 10\n end\n # play again\n if check_end\n @i.cls\n @winner = nil\n @bank = 0\n @open = false\n @loser = nil\n # start new game\n else\n # exit from the program\n @again = false\n end\n end",
"def winner(board)\n WIN_COMBINATIONS.each do |combo|\n if board[combo[0]] == \"X\" && board[combo[1]] == \"X\" && board[combo[2]] == \"X\"\n return \"X\"\n elsif board[combo[0]] == \"O\" && board[combo[1]] == \"O\" && board[combo[2]] == \"O\"\n return \"O\"\n else\n end\n end\n return nil\nend",
"def won?\n WIN_COMBINATIONS.each {|win_combo|\n position_1 = @board.cells[win_combo[0]]\n position_2 = @board.cells[win_combo[1]]\n position_3 = @board.cells[win_combo[2]]\n return win_combo if ((position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"))\n }\n return false\n end",
"def over?\n WIN_COMBINATIONS.each do |combination|\n if combination1 = @board[combination[0]] == \"X\" && @board[combination[1]] == \"X\" && @board[combination[2]] == \"X\" ||\n combination2 = @board[combination[0]] == \"O\" && @board[combination[1]] == \"O\" && @board[combination[2]] == \"O\"\n return true\n end\n end\n draw = full?\n if draw == true\n return true\n else\n return false\n end\n end",
"def won?(board)\n counter = 0\n WIN_COMBINATIONS.select do |potential_win_combo|\n print potential_win_combo\n print \"\\n\"\n\n potential_win_combo.select do |potential_occupied|\n if\n position_taken?(board, potential_occupied)\n puts potential_occupied\n counter += 1\n else\n puts \"no\"\n end\n end\n end\nend",
"def game_results\n if @three_in_row\n puts \"THE WINNER IS #{@player}!!\"\n else\n puts \"ITS A DRAW!!!\"\n end\n end",
"def show_results(win)\n if win\n puts \"Winner!\"\n elsif win == false\n puts \"Loser!\"\n else\n puts \"It's a tie\"\n end\nend",
"def check_for_winner\n winning_spaces_filled = WINNING_SPACES.map {|space| @active_spaces[space[0]] + @active_spaces[space[1]] + @active_spaces[space[2]]}\n if winning_spaces_filled.include?(\"OOO\")\n \"Computer\"\n elsif winning_spaces_filled.include?(\"XXX\")\n \"Player\"\n end\n end",
"def won?(board)\n WIN_COMBINATIONS.each do |combo|\n if board[combo[0]] == \"X\" && board[combo[1]] == \"X\" && board[combo[2]] == \"X\"\n # x wins\n return combo\n end\n \n if board[combo[0]] == \"O\" && board[combo[1]] == \"O\" && board[combo[2]] == \"O\"\n # o wins\n return combo\n end\n end\n\n return false\nend",
"def won?(board)\n if board.none?{|i| i != \" \"}\n return false\n end\n \n \n if board[0] == \"X\" && board[1]== \"X\" && board[2]== \"X\"\n return WIN_COMBINATIONS[0]\n elsif board[3] == \"X\" && board[4] == \"X\" && board[5]== \"X\"\n return WIN_COMBINATIONS[1]\n elsif board[6] == \"X\" && board[7] == \"X\" && board[8]== \"X\"\n return WIN_COMBINATIONS[2]\n elsif board[0] == \"O\" && board[3] == \"O\" && board[6]== \"O\" \n return WIN_COMBINATIONS[3]\n elsif board[1] == \"O\" && board[4] == \"O\" && board[7]== \"O\" \n return WIN_COMBINATIONS[4]\n elsif board[2] == \"O\" && board[5] == \"O\" && board[8]== \"O\" \n return WIN_COMBINATIONS[5]\n elsif board[0] == \"X\" && board[4] == \"X\" && board[8]== \"X\" \n return WIN_COMBINATIONS[6]\n elsif board[6] == \"O\" && board[4] == \"O\" && board[2]== \"O\" \n return WIN_COMBINATIONS[7]\n end\nend",
"def game_over?\n combinations = grab_combos\n result = check_combos(combinations)\n [result[0], result[1]]\n end",
"def won?\n WIN_COMBINATIONS.each do |combo|\n if combo.all? { |i| @board[i].downcase == \"x\"}\n return combo\n elsif combo.all? { |i| @board[i].downcase == \"o\"}\n return combo\n end\n end\n return false\nend",
"def winner\n # checks to see if game was won\n if won?\n winning_array = WIN_COMBINATIONS.detect do |win_array|\n board.cells[win_array[0]] == \"X\" && board.cells[win_array[1]] == \"X\" && board.cells[win_array[2]] == \"X\" ||\n board.cells[win_array[0]] == \"O\" && board.cells[win_array[1]] == \"O\" && board.cells[win_array[2]] == \"O\"\n end\n board.cells[winning_array[0]]\n end\n end",
"def won?(board)\n # binding.pry\n check = false\n WIN_COMBINATIONS.each do |win_combination|\n first_index = win_combination[0]\n second_index = win_combination[1]\n third_index = win_combination[2]\n\n position_1 = board[first_index]\n position_2 = board[second_index]\n position_3 = board[third_index]\n\n if (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n return win_combination\n check = true\n end\n end\n check\nend",
"def won?(board)\n # binding.pry\n check = false\n WIN_COMBINATIONS.each do |win_combination|\n first_index = win_combination[0]\n second_index = win_combination[1]\n third_index = win_combination[2]\n\n position_1 = board[first_index]\n position_2 = board[second_index]\n position_3 = board[third_index]\n\n if (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n return win_combination\n check = true\n end\n end\n check\nend",
"def won?(board_array)\n winning_combo = nil\n #create a varibale to store code to check if board is empty\n empty_or_not = board_array.all? do |index|\n index == \" \"\n end\n #checks to see of board is empty or not\n if empty_or_not\n return false\n else\n #logic to check for a winning combination\n WIN_COMBINATIONS.each do |combo|\n if board_array[combo[0]] == \"X\" && board_array[combo[1]] == \"X\" && board_array[combo[2]] == \"X\"\n winning_combo = combo\n elsif board_array[combo[0]] == \"O\" && board_array[combo[1]] == \"O\" && board_array[combo[2]] == \"O\"\n winning_combo = combo\n end\n end\nend\n return winning_combo\nend",
"def won?(board)\n game = false\n WIN_COMBINATIONS.each do |win_combination|\n if !game\n if win_combination.all?{|i| board[i]==\"X\"} || win_combination.all?{|i| board[i]==\"O\"}\n game = win_combination\n end\n end\n end\n game\n end",
"def won?(board)\n WIN_COMBINATIONS.each do |win_index| #interates thru list of win combinations array\n\n x_win = win_index.all? do |spot| #interates thru individual win array\n\n board[spot] == \"X\"\n\n end\n\n o_win = win_index.all? do |spot|\n\n board[spot] == \"O\"\n\n end\n\n if x_win || o_win\n\n return win_index\n\n end\n end\n else\n return false\nend",
"def won?\n answer = true\n WIN_COMBINATIONS.each do |win_combination|\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n \n position_1 = board[win_index_1] \n position_2 = board[win_index_2] \n position_3 = board[win_index_3]\n\n\n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n return answer = win_combination\n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n return answer = win_combination\n else\n answer = false\n end\n end\n answer\nend",
"def won?\n WIN_COMBINATIONS.find do |combo|\n board.cells[combo[0]] == board.cells[combo[1]] && board.cells[combo[1]] == board.cells[combo[2]] && board.cells[combo[0]] != \" \"\n end\n end",
"def won?\n WIN_COMBINATIONS.any? do |combo|\n @board.cells[combo[0]] == @board.cells[combo[1]] && @board.cells[combo[0]] == @board.cells[combo[2]] && @board.cells[combo[0]] != \" \"\n end\n end",
"def won?(board)\n return false if board.all?{|x| x == \" \"}\n WIN_COMBINATIONS.each do |wincombo|\n if wincombo.all?{|idx| board[idx] == \"X\"} || wincombo.all?{|idx| board[idx] == \"O\"}\n return wincombo\n end\n end\n false\nend",
"def won? (board)\n #for each row, column and diagnonal combination\n WIN_COMBINATIONS.each do | win_combination |\n #grab the winning combinaation of indices we are looking for\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n #extract the value of these winning indices from the board\n position_1 = board[win_index_1]\n position_2 = board[win_index_2]\n position_3 = board[win_index_3]\n\n\n #check if either team has won\n if (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n #we break out of here if we have a winning row, col, or diagnonal\n return win_combination\n end #end if\n end #end for each\n\n #if we get here the board may be empty\n #if we get here the board may be filled, but no winning combos\n return false\nend",
"def won?\n WIN_COMBINATIONS.detect do |combo|\n @board[combo[0]] == @board[combo[1]] &&\n @board[combo[1]] == @board[combo[2]] &&\n position_taken?(combo[0])\n end\nend",
"def won?\n if empty?\n return false\n end\n\n WIN_COMBINATIONS.each do |win_combination|\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n position_1 = @board[win_index_1] # load the value of the board at win_index_1\n position_2 = @board[win_index_2] # load the value of the board at win_index_2\n position_3 = @board[win_index_3] # load the value of the board at win_index_3\n\n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n return win_combination # return the win_combination indexes that won.\n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n return win_combination # return the win_combination indexes that won.\n else\n false\n end\n end\n\n if full?\n return false\n end\n end",
"def won?(board) \n winning_array = []\n\n WIN_COMBINATIONS.each do |combo|\n board_values = []\n combo.each do |position_value|\n board_values.push(board[position_value]) \n #puts \"the current board value is #{board_values}\" \n end\n if board_values.all?{|values| values == \"X\" }|| board_values.all?{|values| values == \"O\"}\n winning_array = combo\n end\n end\n \n if winning_array == [] && full?(board) == true\n winning_array = false\n end\n\n if board.all?{|values| values == \" \" }|| board.all?{|values| values == \"\"}\n winning_array = false\n end\n\n winning_array \n\nend",
"def won?(board)\n if board == [\" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \", \" \"]\n return false\n end\n\n#counting so we don't return false until we have looked at all of the combinations.\ncount = 0\n\n WIN_COMBINATIONS.each do |combo|\n count = count + 1\n if board[combo[0]] == \"X\" && board[combo[1]] == \"X\" && board[combo[2]] == \"X\"\n return combo\n elsif board[combo[0]] == \"O\" && board[combo[1]] == \"O\" && board[combo[2]] == \"O\"\n return combo\n elsif count == 8\n return false\n end\n end\nend",
"def won?(board)\n WIN_COMBINATIONS.each do |combo|\n win_combination = [combo[0], combo[1], combo[2]]\n windex1 = win_combination[0]\n windex2 = win_combination[1]\n windex3 = win_combination[2]\n\n pos1 = board[windex1]\n pos2 = board[windex2]\n pos3 = board[windex3]\n win_combo = [pos1,pos2,pos3]\n\n if pos1 == \"X\" && pos2 == \"X\" && pos3 == \"X\" || pos1 ==\"O\" && pos2 == \"O\" && pos3 == \"O\"\n return win_combination\n end\nend\n return false\nend",
"def win_game\n clear_message_box\n @ui.place_text('THY QUEST IS OVER!'.center(20),1,2)\n (0..36).each do |i|\n hero_direction = POS_TURN.rotate!(i <=> 16)[0]\n @ui.place_text(DungeonOfDoom::CHAR_PLAYER[hero_direction], @cur_x+2, @cur_y+6, DungeonOfDoom::C_WHITE_ON_RED)\n sleep 0.1\n @ui.refresh\n end\n ask_question(\"THY SCORE=#{((@treasure*10)+(@gold_count*@stats[:experience])+@stats[:strength]+\n @stats[:vitality]+@stats[:agility]).round}\",MSG_KEY)\n end",
"def output\n if player1_wins > player2_wins\n puts \"Player 1: (with a score of) #{player1_wins}\\n\\n Won this game! \\n\\nAfter #{round_number} rounds and survived #{tie} WARs.\"\n elsif player1_wins < player2_wins\n puts \"Player 2: (with a score of) #{player2_wins}\\n\\n Won this game! \\n\\nAfter #{round_number} rounds and survived #{tie} WARs.\"\n # else\n # puts \"ERRRRRRRRRROOOOOOOOOORRRRRR\"\n # puts player1_wins\n # puts player2_wins\n # puts tie\n end\n end",
"def game_over\n [:winner, :tie].include?(board.status)\n end",
"def won?\n if @board.all?{|position|position == \" \"}\n return false\n end\n no_combinations = true\n WIN_COMBINATIONS.each do |combination|\n if combination1 = @board[combination[0]] == \"X\" && @board[combination[1]] == \"X\" && @board[combination[2]] == \"X\" ||\n combination2 = @board[combination[0]] == \"O\" && @board[combination[1]] == \"O\" && @board[combination[2]] == \"O\"\n no_combinations = false\n return combination\n end\n end\n if no_combinations == true\n return false\n end\n end",
"def who_win?\n count_turn = 0\n\n while count_turn <= 0 \n \n if @A1.content == \"O\" && @A2.content == \"O\" && @A3.content == \"O\" && @A1.content == \"X\" && @A2.content == \"X\" && @A3.content == \"X\"\n @winning_game = true \n end\n\n if @B1.content == \"O\" && @B2.content == \"O\" && @B3.content == \"O\" && @B1.content == \"X\" && @B2.content == \"X\" && @B3.content == \"X\"\n @winning_game = true \n end\n\n if @C1.content == \"O\" && @C2.content == \"O\" && @C3.content == \"O\" && @C1.content == \"X\" && @C2.content == \"X\" && @C3.content == \"X\"\n @winning_game = true \n end\n\n if @A1.content == \"O\" && @B1.content == \"O\" && @C1.content == \"O\" && @A1.content == \"X\" && @B1.content == \"X\" && @C1.content == \"X\"\n @winning_game = true \n end\n\n if @A2.content == \"O\" && @B2.content == \"O\" && @C2.content == \"O\" && @A2.content == \"X\" && @B2.content == \"X\" && @C2.content == \"X\"\n @winning_game = true \n end\n\n if @A3.content == \"O\" && @B3.content == \"O\" && @C3.content == \"O\" && @A3.content == \"X\" && @B3.content == \"X\" && @C3.content == \"X\"\n @winning_game = true \n end\n\n if @A1.content == \"O\" && @B2.content == \"O\" && @C3.content == \"O\" && @A1.content == \"X\" && @B2.content == \"X\" && @C3.content == \"X\"\n @winning_game = true \n end\n\n if @A3.content == \"O\" && @B2.content == \"O\" && @C1.content == \"O\" && @A3.content == \"X\" && @B2.content == \"X\" && @C1.content == \"X\"\n @winning_game = true \n end\n\n count_turn += 1\n end\n\n if count_turn == 9 \n equality_game = true\n end\n end",
"def won?\n WIN_COMBINATIONS.detect do |win_combination|\n @board[win_combination[0]] == @board[win_combination[1]] &&\n @board[win_combination[1]] == @board[win_combination[2]] &&\n position_taken?(win_combination[0])\n end\nend",
"def game_check(player_symbol, player_name,turn)\n win_conditions = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]\n win_conditions.each do |condition|\n print \"\\n#{player_name} win!\" if condition.all?{|element| @space[element]==player_symbol}\n end\n print \"\\nTie game!\" if turn == 8\n end",
"def won?(board)\nWIN_COMBINATIONS.detect do |win_combination|\n if board[win_combination[0]] == \"X\" && board[win_combination[1]] == \"X\" && board[win_combination[2]] == \"X\"\n win_combination\n elsif board[win_combination[0]] == \"O\" && board[win_combination[1]] == \"O\" && board[win_combination[2]] == \"O\"\n win_combination\n else\n end\n end\nend",
"def check_win\n\tp = tokenize($current_player)\n\tvert1 = $row1[0] + $row2[0] + $row3[0]\n\tvert2 = $row1[2] + $row2[2] + $row3[2]\n\tvert3 = $row1[4] + $row2[4] + $row3[4]\n\n\thorz1 = vert1[0] + vert2[0] + vert3[0]\n\thorz2 = vert1[1] + vert2[1] + vert3[1]\n\thorz3 = vert1[2] + vert2[2] + vert3[2]\n\n\tdiag1 = $row1[0] + $row2[2] + $row3[4]\n\tdiag2 = $row3[0] + $row2[2] + $row1[4]\n\n\twinning_options = [vert1, vert2, vert3, horz1, horz2, horz3, diag1, diag2]\n\tif winning_options.any? {|x| (x.count p) >= 3}\n\t\treturn true\n\tend \nend",
"def game\n print @hidden\n puts\n print @open\n puts\n preparation\n c = Combination.new(@hidden, @open)\n c.find_combination\n end",
"def won?\n WIN_COMBINATIONS.detect do |combo|\n @board.cells[combo[0]] == @board.cells[combo[1]] &&\n @board.cells[combo[1]] == @board.cells[combo[2]] &&\n @board.taken?(combo[0]+1)\n end\n end",
"def won?\n\n WIN_COMBINATIONS.each do |current_combo|\n\n win_x = current_combo.all? { |position| @board[position] == \"X\" }\n win_o = current_combo.all? { |position| @board[position] == \"O\"}\n\n if win_x || win_o\n return current_combo\n\n end\n end\n false\n end",
"def gameover(game)\n if game.full_board?() #Si el tablero se lleno primero es que hubo un empate\n puts \"GAME OVER\"\n return \"draw\"\n end\n if game.match() #Si se tiene match de fichas\n puts \"TIC TAC TOE\"\n return \"win\"\n end\nend",
"def won?(board)\n WIN_COMBINATIONS.each do |win_combo|\n if (board[win_combo[0]] == \"X\" && board[win_combo[1]] == \"X\" && board[win_combo[2]] == \"X\") || (board[win_combo[0]] == \"O\" && board[win_combo[1]] == \"O\" && board[win_combo[2]] == \"O\")\n return win_combo\n end\n end\n return false\nend",
"def won?\r\n WIN_COMBINATIONS.detect do |combo|\r\n @board[combo[0]] == @board[combo[1]] &&\r\n @board[combo[1]] == @board[combo[2]] && @board[combo[0]] != \" \"\r\n end\r\n end",
"def won? (board)\n if (board[WIN_COMBINATIONS[0][0]] == 'X' && board[WIN_COMBINATIONS[0][1]] == 'X' && board[WIN_COMBINATIONS[0][2]] == 'X')\n return WIN_COMBINATIONS[0]\n elsif (board[WIN_COMBINATIONS[0][0]] == 'O' && board[WIN_COMBINATIONS[0][1]] == 'O' && board[WIN_COMBINATIONS[0][2]] == 'O')\n return WIN_COMBINATIONS[0]\n end\n\n if (board[WIN_COMBINATIONS[1][0]] == 'X' && board[WIN_COMBINATIONS[1][1]] == 'X' && board[WIN_COMBINATIONS[1][2]] == 'X')\n return WIN_COMBINATIONS[1]\n elsif (board[WIN_COMBINATIONS[1][0]] == 'O' && board[WIN_COMBINATIONS[1][1]] == 'O' && board[WIN_COMBINATIONS[1][2]] == 'O')\n return WIN_COMBINATIONS[1]\n end\n\n if (board[WIN_COMBINATIONS[2][0]] == 'X' && board[WIN_COMBINATIONS[2][1]] == 'X' && board[WIN_COMBINATIONS[2][2]] == 'X')\n return WIN_COMBINATIONS[2]\n elsif (board[WIN_COMBINATIONS[2][0]] == 'O' && board[WIN_COMBINATIONS[2][1]] == 'O' && board[WIN_COMBINATIONS[2][2]] == 'O')\n return WIN_COMBINATIONS[2]\n end\n\n if (board[WIN_COMBINATIONS[3][0]] == 'X' && board[WIN_COMBINATIONS[3][1]] == 'X' && board[WIN_COMBINATIONS[3][2]] == 'X')\n return WIN_COMBINATIONS[3]\n elsif (board[WIN_COMBINATIONS[3][0]] == 'O' && board[WIN_COMBINATIONS[3][1]] == 'O' && board[WIN_COMBINATIONS[3][2]] == 'O')\n return WIN_COMBINATIONS[3]\n end\n\n if (board[WIN_COMBINATIONS[4][0]] == 'X' && board[WIN_COMBINATIONS[4][1]] == 'X' && board[WIN_COMBINATIONS[4][2]] == 'X')\n return WIN_COMBINATIONS[4]\n elsif (board[WIN_COMBINATIONS[4][0]] == 'O' && board[WIN_COMBINATIONS[4][1]] == 'O' && board[WIN_COMBINATIONS[4][2]] == 'O')\n return WIN_COMBINATIONS[4]\n end\n\n if (board[WIN_COMBINATIONS[5][0]] == 'X' && board[WIN_COMBINATIONS[5][1]] == 'X' && board[WIN_COMBINATIONS[5][2]] == 'X')\n return WIN_COMBINATIONS[5]\n elsif (board[WIN_COMBINATIONS[5][0]] == 'O' && board[WIN_COMBINATIONS[5][1]] == 'O' && board[WIN_COMBINATIONS[5][2]] == 'O')\n return WIN_COMBINATIONS[5]\n end\n if (board[WIN_COMBINATIONS[6][0]] == 'X' && board[WIN_COMBINATIONS[6][1]] == 'X' && board[WIN_COMBINATIONS[6][2]] == 'X')\n return WIN_COMBINATIONS[6]\n elsif (board[WIN_COMBINATIONS[6][0]] == 'O' && board[WIN_COMBINATIONS[6][1]] == 'O' && board[WIN_COMBINATIONS[6][2]] == 'O')\n return WIN_COMBINATIONS[6]\n end\n if (board[WIN_COMBINATIONS[7][0]] == 'X' && board[WIN_COMBINATIONS[7][1]] == 'X' && board[WIN_COMBINATIONS[7][2]] == 'X')\n return WIN_COMBINATIONS[7]\n elsif (board[WIN_COMBINATIONS[7][0]] == 'O' && board[WIN_COMBINATIONS[7][1]] == 'O' && board[WIN_COMBINATIONS[7][2]] == 'O')\n return WIN_COMBINATIONS[7]\n end\nelse\n return false\nend",
"def winner\n if winning_combo = won?\n @board[winning_combo.first]\n end\n end",
"def win_check\n \tchecks = [horizontal_check, vertical_check, diagonal_check, diamond_check,\n \t\t\t inside_check, outside_check, postage_check]\n\t\n\tif checks.include?(true)\n\t\treturn \"BINGO!! Your a winner\"\n\telse\n\t\treturn \"Sorry you have not won\"\n\tend\n end",
"def won?\n ::WIN_COMBINATIONS.detect do |combo|\n board.cells[combo[0]] == @board.cells[combo[1]] &&\n board.cells[combo[1]] == @board.cells[combo[2]] &&\n board.taken?(combo[0]+1)\n end\n end",
"def won?(board)\n WIN_COMBINATIONS.each do |win_combination|\n if board[win_combination[0]] == \"X\" && board[win_combination[1]] == \"X\" && board[win_combination[2]] == \"X\"\n return win_combination\n elsif board[win_combination[0]] == \"O\" && board[win_combination[1]] == \"O\" && board[win_combination[2]] == \"O\"\n return win_combination\n end\n end\n return false\nend",
"def won?(board)\n empty_board = board.all? do |element|\n element.nil? || element == \" \"\n end\n if empty_board\n return false\n end\n # For each win_combination in WIN_COMBINATIONS\n # win_combination is a 3 element array of indexes that compose a win, [0,1,2]\n WIN_COMBINATIONS.each do |win_combination|\n # grab each index from the win_combination that composes a win.\n win_index_1 = win_combination[0]\n win_index_2 = win_combination[1]\n win_index_3 = win_combination[2]\n\n position_1 = board[win_index_1] # load the value of the board at win_index_1\n position_2 = board[win_index_2] # load the value of the board at win_index_2\n position_3 = board[win_index_3] # load the value of the board at win_index_3\n\n # puts \"#{win_combination}\"\n if (position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\") ||\n (position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\")\n return win_combination # return the win_combination indexes that won.\n else\n false\n end\n end\n\n return false\n\nend",
"def won?\n WIN_COMBINATIONS.each do |combination|\n win_index_1 = combination[0]\n win_index_2 = combination[1]\n win_index_3 = combination[2]\n \n position_1 = @board[win_index_1] # load the value of the board at win_index_1\n position_2 = @board[win_index_2] # load the value of the board at win_index_2\n position_3 = @board[win_index_3] # load the value of the board at win_index_3\n \n if position_1 == \"X\" && position_2 == \"X\" && position_3 == \"X\"\n return combination # return the win_combination indexes that won.\n elsif position_1 == \"O\" && position_2 == \"O\" && position_3 == \"O\"\n return combination # return the win_combination indexes that won.\n end\n end\n false\n end",
"def print_outcome()\n\t\t#call compare players\n\t\t@outcome = compare_players(Array.new(5,true),0)\n\t\t#check for tie\n\t\tif @outcome == -1 then\n\t\t\tputs (\"Game was a tie\")\n\t\t#print outcome\n\t\telse\n\t\t\tputs (\"Player #{@players[@outcome].name} won\")\n\t\tend\n\tend"
] | [
"0.7708189",
"0.7102432",
"0.7102285",
"0.7071653",
"0.7049752",
"0.7016944",
"0.70160806",
"0.701148",
"0.69719565",
"0.6945492",
"0.6941701",
"0.69380283",
"0.6912952",
"0.6906618",
"0.69010764",
"0.6891594",
"0.6879269",
"0.68765354",
"0.68699837",
"0.686527",
"0.68458503",
"0.68274367",
"0.6788577",
"0.677784",
"0.67592597",
"0.67566997",
"0.6736277",
"0.67301863",
"0.67297596",
"0.6726571",
"0.6720568",
"0.67111075",
"0.6706593",
"0.6703719",
"0.6700514",
"0.66990817",
"0.66803014",
"0.6678003",
"0.6672971",
"0.6667131",
"0.66600066",
"0.66594505",
"0.6653071",
"0.6652352",
"0.6652352",
"0.66449845",
"0.66381204",
"0.6629246",
"0.66261625",
"0.6619905",
"0.66046834",
"0.6595166",
"0.65942246",
"0.65903443",
"0.65884846",
"0.6588342",
"0.65865386",
"0.6583419",
"0.65802246",
"0.6568737",
"0.65683377",
"0.65654504",
"0.65652025",
"0.6562532",
"0.6562532",
"0.65615666",
"0.655858",
"0.65584874",
"0.6557347",
"0.6554844",
"0.65465415",
"0.6541616",
"0.65409803",
"0.6540366",
"0.65396076",
"0.6535574",
"0.65344083",
"0.6531904",
"0.6531222",
"0.65299654",
"0.65295756",
"0.6528659",
"0.6527951",
"0.6521802",
"0.6518834",
"0.6518059",
"0.65172905",
"0.6514997",
"0.651396",
"0.6513092",
"0.6512313",
"0.65098155",
"0.65062505",
"0.6503555",
"0.65015584",
"0.650075",
"0.65006703",
"0.64927924",
"0.6492127",
"0.6492058",
"0.6490713"
] | 0.0 | -1 |
returns true if every element of the board is full | def full?(board)
if !(won?(board))
board.each do |e|
if (e != "X" && e != "O")
return false
end
end
end
return true
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isBoardFull()\n #\n # TO DO: add your code below\n #\n for i in 0...@size\n for j in 0...@size\n if (@board[i][j]==EMPTY)\n return false\n end\n end\n end\n\n # DO NOT DELETE THE LINE BELOW\n\t\treturn true;\n\tend",
"def isBoardFull()\n #\n # TO DO: add your code below\n\t\t#\n\t\tfor i in ([email protected])\n\t\t\tfor j in ([email protected])\n\t\t\t\tif @board[i][j] == EMPTY\n\t\t\t\t\treturn false\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\n # DO NOT DELETE THE LINE BELOW\n\t\treturn true;\n\tend",
"def board_full?\n @board.each do |row|\n row.each do |col|\n if col == @empty_square\n #stop at first empty space found\n return nil\n end\n end\n end\n return true\n end",
"def full?\n @board.all?{|occupied| occupied != \" \"}\n end",
"def isBoardFull()\n\n # TO DO: COMPLETE THIS PART OF THE METHOD\n\n counter = 0\n totalSpaces = @size * @size\n\n for i in 0..@size-1\n for j in 0..@size-1\n if @board[i][j] != \"-\"\n counter = counter + 1\n end\n end\n end\n\n if counter == totalSpaces\n return true\n end\n\n\t\treturn false\n end",
"def full? #if theres no winning combos and the board is full? check to see\n @board.all?{|square| square!= \" \" }\n end",
"def board_full?(brd)\n empty_squares(brd).empty?\n end",
"def board_full\n\n # Assume the board is full\n result = true\n\n # Outer loop through each row\n for row in 0..BOARD_MAXIMUM_INDEX\n\n # Inner loop through each column\n for column in 0..BOARD_MAXIMUM_INDEX\n\n # Is this cell occupied?\n if @board[row][column] == EMPTY_POSITION\n\n # No, the board is not full and the game must continue\n result = false\n\n end\n\n end\n\n end\n\n # Since we found no open positions, the board is full\n return result\n\n end",
"def board_full?\n @board.flatten.all?\n @turn == 9 \n end",
"def board_full?(brd)\n empty_squares(brd).empty?\nend",
"def board_full?(brd)\n empty_squares(brd).empty?\nend",
"def full?\n answer= @board.each {|box| return false if taken?(box) == false }\n unless answer ==false \n true\n end\n end",
"def is_board_full(board)\n for i in 1..10\n if is_space_free(board, i)\n return false\n end\n end \n\n return true\nend",
"def full?\n @board.all?{|occupied| occupied != \" \"}\nend",
"def full?\n @board.all?{|occupied| occupied != \" \"}\nend",
"def board_full?\r\n @game_board.count(\"\") == 0\r\n end",
"def full?(board)\n filled_tiles = 0\n board.each { |tile| tile == \"X\" || tile == \"O\" ? (filled_tiles += 1) : ()}\n filled_tiles == 9 ? (return true) : (return false)\nend",
"def check_full? \n \t\treturn true if @size==16 #size increase by 1 with every turn so when it reaches 16 we know that all cells are full\n\tend",
"def full?\n @board.all? do |position|\n position != \" \"\n end\n end",
"def full?\n @board.all? do |position|\n position != \" \"\n end\n end",
"def is_full?\n\t\t@game_board.each do |x|\n\t\t\tx.each do |y|\n\t\t\t\tif y == \"\"\n\t\t\t\t\treturn false\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\ttrue\n\tend",
"def full?\n is_full = @board.all? do |space|\n space ==\"X\" || space == \"O\"\n end\n if is_full\n true\n end\n end",
"def full?\n return @board.all?{|pos| pos == \"X\" or pos == \"O\"}\n end",
"def is_full?\n\t @grid.all? { |col| col.length == @rows }\n\tend",
"def full_board?\n @board.cells.each do |row|\n row.each do |cell|\n return false if cell.state == \" \"\n end\n end\n true\n end",
"def full?(board)\n board.each do |i|\n if i == \" \"\n return false\n end\n end\n return true\n # checks whether each element on the board is empty if not return false (not empty) otherwise return true(full)\nend",
"def full?\n # If no 'board_position'/s are empty, returns 'true'. If 'board_position'/s remain empty, returns 'false'.\n if @board.none? {|board_position| board_position == \" \"}\n true\n end\n end",
"def full?(board)\n if won?(board) == false && board.all? {|element| element != \" \"}\n return true\n else\n false\n end\nend",
"def full?(board) #check if the board is full\n board.each_with_index do |position, index|\n if position_taken?(board, index) == false \n return false\n end\n end\n return true\nend",
"def full?\n @board.all? {|position| position == \"X\" or position == \"O\"}\n end",
"def full?\n @board.all? {|space| space == \"X\" || space == \"O\"}\n end",
"def full?\n @board.all? {|i| i == \"X\" || i == \"O\"}\n end",
"def full?\n #return true if every element in the board contains something\n if @board.detect {|i| i == \" \" || i == nil}\n return false\n else\n return true\n end\nend",
"def full?\n @board.all? { |location| location != \" \"}\n end",
"def check_full(board)\n return true if board.all? { |i| i == \"x\" || i == \"o\" }\n return false\n end",
"def full?\r\n @board.none? do | position |\r\n position == \" \"\r\n end\r\n end",
"def full?\n\t\[email protected]? { |e|\n\t\t\te == \"X\" || e == \"O\"\n\t\t}\n\tend",
"def full?(board_array)\n board_check = board_array.all? do |space|\n space != \" \"\n end\n \n if board_check\n return true #situation for a draw\n else\n return false #situation for an in-progress game\n end\nend",
"def full?(board_array)\r\n board_check = board_array.all? do |space|\r\n space != \" \"\r\n end\r\n \r\n if board_check\r\n return true #situation for a draw\r\n else\r\n return false #situation for an in-progress game\r\n end\r\nend",
"def full?()\n @board.each do |values|\n if values == \" \" || values == \"\"\n return false\n end\n end\n return true\n end",
"def full?\n any_spaces = @board.any?{|element| element == \" \"}\n if any_spaces == true\n return false\n else\n return true\n end\n end",
"def full?(board)\n board.all?{|filled| filled == \"X\" || filled == \"O\"}\nend",
"def full?\r\n @board.each do |space|\r\n if space == \" \"\r\n return false\r\n end\r\n end\r\n true\r\n end",
"def full?(board)\n all_full = false\n board.all? do |space|\n if space == \"X\" || space == \"O\"\n all_full = true\n end\n end\nend",
"def full?(board)\n board_is_full = board.all? do |space|\n space == \"X\" || space == \"O\"\n end\n return board_is_full\nend",
"def is_full?\n\t @grid.flatten.all? { |elem| !elem.empty? }\n\tend",
"def full?(board)\n if @board.any? {|index| index == nil || index == \" \"}\n return false\n else\n return true\n end\n end",
"def full?\n result = @board.none? {|mark| mark==\" \"}\n return result\n end",
"def full?\n @board.all? {|value| value == \"X\" || value ==\"O\"}\n end",
"def full?(board)\n board.all? {|indexs| indexs != \" \"}\nend",
"def full?\n @board.all? { |e| !(e.nil? || e == \" \") }\nend",
"def full?(board)\n board.all? {|x| x != \" \"}\nend",
"def fullBoard(position)\n for x in 0..2\n for y in 0..2\n if position[x][y] == 0\n return false\n end\n end\n end\n return true\n end",
"def full?(board)\n board_full = board.all? {|position| position == 'X' || position == 'O'}\n\n if (board_full)\n return true\n end\nend",
"def full?(board)\n#Return true if all positions on board are filled by X and/or O\n board.all?{|token| token == \"X\" || token == \"O\"}\nend",
"def full?(board)\n is_full = board.all? do |position|\n (position == \"X\" || position == \"O\")\n end\n return is_full\nend",
"def full?\n return (@fill_count == size)\n end",
"def full?(board)\n\tboard.all? do |cell|\n\t\tcell == \"X\" || cell == \"O\"\n\tend\nend",
"def full?(board)\n board.all?{|a| (a==\"X\" || a== \"O\")}\nend",
"def board_full?(board)\n !board.include?(\"\")\n end",
"def full?\n @board.all? do |location| \n location == \"X\" || location == \"O\"\n end\n end",
"def full?\n @board.all?{|token| token == \"X\" || token == \"O\"}\n end",
"def full? \n\[email protected]? {|a| a.include?(\" \")} ? false : true\n\tend",
"def full?(board)\n\n full_board = [0,1,2,3,4,5,6,7,8].all? {|index| position_taken?(board, index)}\n return full_board\n\nend",
"def full?(board)\n\t\tboard.all?{|cell| cell == \"X\" || cell == \"O\"}\n\tend",
"def full?\n each_cell do |cell|\n return false unless cell\n end\n true\n end",
"def full?\n if @board.detect{|i| i == \"\" || i == \" \"}\n return false\n else\n return true\n end\n end",
"def full?(board)\n return !(board & [\" \", \"\", nil]).any?\nend",
"def full?(board)\n return board.all?{|pos| pos == \"X\" or pos == \"O\"}\nend",
"def full?\n @board.cells.include?(\"\") || @board.cells.include?(\" \") ? false : true\n end",
"def board_full?(board)\n false\n true unless board.include?(INITIAL_MARKER)\nend",
"def full?\n @board.all? { |token| token == \"X\" || token == \"O\" }\n end",
"def full?\n grid.each do |row|\n row.each do |location|\n return false if location.nil?\n end\n end\n true\n end",
"def full?\n [email protected]{|i| i == \" \"}\n end",
"def full?\n @board.all? { |x| x == \"X\" || x == \"O\" } \nend",
"def full?(board)\n board.all? {|full| full != \" \"} ? true : false\nend",
"def full\n @moves.length >= 12\n end",
"def full?(board)\n board.all? do|index|\n index != \" \"\n end\nend",
"def full?(board)\n board.all? do |position|\n !(position.nil? || position == \" \" || position == \"\")\n end\nend",
"def full?\n available_squares.empty?\n end",
"def full?(board)\r\n #return true if every element in the board contains something\r\n board.each do |element|\r\n if (element == \" \") \r\n return false\r\n end\r\n end\r\n return true\r\nend",
"def full?\n #if there is a blank space, returns false, otherwise true\n !(@board.detect {|posit| posit == \" \"})\n end",
"def full?(board)\n board.all?{|position| position == \"X\" || position == \"O\"}\nend",
"def full?(board)\n board.each do |space|\n if space == \"X\" || space == \"O\"\n else\n return false\n end\n end\n true\nend",
"def full?(board)\n return board.none? {|xo| xo == \" \"}\nend",
"def full?(board)\n answer = true\n board.each do |token|\n if token != \"X\" && token != \"O\"\n answer = false\n end\n end\n\tanswer\n # other solution - board.all?{|token| token == \"X\" || token == \"O\"}\nend",
"def full?(board)\n board.all? { |space| space == \"X\" || space == \"O\"}\nend",
"def full?(board)\n board.all? { |space| space == \"X\" || space == \"O\"}\nend",
"def full?\n [email protected]? { |value| value.nil? || value == \"\" || value == \" \" }\n end",
"def full_board (board)\n board.each_index do |row_index|\n return false if board[row_index].include?(\"-\")\n end\n return true\n end",
"def all_cells_cleared?\n @board.each do |row|\n row.each do |cell|\n if !cell.has_bomb && !cell.is_open\n return false\n end\n end\n end\n true\n end",
"def full?(board)\n board.all? do |marker|\n marker == \"X\" || marker == \"O\"\n end\n end",
"def full?(board)\n board.all?{|token| token == \"X\" || token == \"O\"}\n\n # true if board.count(\"X\") + board.count(\"O\") == 9\nend",
"def on_board?(coords)\n\t\tcoords.any? {|coord| coord < 1 || coord > @size } ? false : true\n\tend",
"def full?(board)\n board.all? {|element| element == \"X\" || element == \"O\"}\nend",
"def full?(board)\n board.all? { |element| element == \"X\" || element == \"O\" }\nend",
"def full?(board)\n board.all? { |element| element == \"X\" || element == \"O\" }\nend",
"def board_complete?(b)\n result = b.select do |sub_array|\n sub_array.any?(0)\n end\n result.empty?\nend",
"def full?(board)\n board.all? { |i| i == \"X\" || i == \"O\" }\n end",
"def full?\n @board.detect{|entry| entry==\" \"}==nil ? true : false\nend",
"def full?\n @cells.map { |row| row.all? {|cell| !cell.eql?(' ') } }.all?(true)\n end"
] | [
"0.8843037",
"0.88111204",
"0.8728713",
"0.8623876",
"0.858383",
"0.85729814",
"0.8564752",
"0.856049",
"0.85387486",
"0.85120463",
"0.85120463",
"0.84112716",
"0.8379702",
"0.8340113",
"0.8340113",
"0.8321056",
"0.82815343",
"0.82795346",
"0.8271862",
"0.8271862",
"0.82651514",
"0.8209685",
"0.82052535",
"0.8193949",
"0.8183087",
"0.8180965",
"0.8160656",
"0.8158374",
"0.8155852",
"0.8103122",
"0.80837804",
"0.8039001",
"0.801426",
"0.800146",
"0.7986949",
"0.7980943",
"0.7977633",
"0.7969557",
"0.79608625",
"0.79589444",
"0.7950698",
"0.7938686",
"0.7933701",
"0.7914093",
"0.7904593",
"0.79027116",
"0.78848547",
"0.7883504",
"0.78709906",
"0.78598475",
"0.78596234",
"0.7854086",
"0.7835118",
"0.78199583",
"0.77959245",
"0.77950597",
"0.7790928",
"0.7790482",
"0.77898484",
"0.7788763",
"0.7786705",
"0.7779943",
"0.7776401",
"0.7766226",
"0.7752873",
"0.7751053",
"0.77442104",
"0.77417785",
"0.7736257",
"0.77350473",
"0.77329624",
"0.7732257",
"0.7727362",
"0.7724205",
"0.7718916",
"0.7718836",
"0.7706662",
"0.7696789",
"0.7681243",
"0.7676203",
"0.76586545",
"0.7657445",
"0.76430434",
"0.7639546",
"0.7631655",
"0.76280206",
"0.7618617",
"0.7618617",
"0.7614293",
"0.7611831",
"0.7588579",
"0.75852585",
"0.7578546",
"0.757488",
"0.7572695",
"0.75721365",
"0.75721365",
"0.75666016",
"0.7563732",
"0.75487506",
"0.7546424"
] | 0.0 | -1 |
end of game status main application method responsible for game loop | def play(board)
while !(over?(board))
display_board(board)
turn(board)
end
if won?(board) != false
puts "Congratulations #{winner(board)}!"
elsif draw?(board)
puts "Cats Game!"
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def end_game\n\n end",
"def end_game\n end",
"def main_end\r\n # Refresh map\r\n $game_map.refresh\r\n # If switching to title screen\r\n if $scene.is_a?(Scene_Title)\r\n # Fade out screen\r\n Graphics.transition\r\n Graphics.freeze\r\n end\r\n # If switching from battle test to any screen other than game over screen\r\n if $BTEST and not $scene.is_a?(Scene_Gameover)\r\n $scene = nil\r\n end\r\n end",
"def end_game\n @game_run = false\n puts \"Game Over\"\n puts\n end",
"def end_game\n\t\tputs \"Goodbye!\"\n\t\texit\n\tend",
"def finalize_game\n\n end",
"def end\n\t\tputs \"----- GAME OVER -----\"\n\t\tputs \"Good bye!\"\n\tend",
"def end_game\r\n @game_over = true\r\n end",
"def end_game\n puts \"Merci, Aur revoir\"\n end",
"def victory_end\n RPG::BGM.fade(500) unless skip?\n 20.times do; Graphics.update; end\n SceneManager.return\n battle_end(0)\n replay_bgm_and_bgs unless skip? || $BTEST\n end",
"def game_loop\n end",
"def battle_end\n log_info('Exiting battle')\n # TODO : battle_end procedure\n $game_temp.in_battle = false\n return_to_last_scene\n end",
"def game_loop\n end",
"def game_exit\n Message.game_quit\n false\n end",
"def exit\n @main_loop = false\n end",
"def end_game()\n get_winners()\n end",
"def end_game\n puts \"Thank to play my game. See you again.\"\n end",
"def end_of_the_game\n @display.throw(self)\n puts \"THIS IS THE END OF THE GAME\"\n puts ''\n if @current_board.boardcase_array.any? { |boardcase| boardcase.status == nil } == false\n puts 'I am afraid this a DRAW T_T'\n else\n puts \"Wow! #{@player_turn.name} you did win this one\"\n @player_turn == @player_one ? (@score_player_one += 1) : (@score_player_two += 1)\n end\n puts \"#{@player_one.name} :#{@score_player_one} victories\"\n puts \"#{@player_two.name} :#{@score_player_two} victories\"\n puts ''\n puts ''\n print \"DO YOU WANT TO TRY AGAIN? Y/n\"\n choice = gets.chomp\n exit unless choice == \"Y\"\n end",
"def end_game\n puts \"\\n\\n________ GAME OVER ________\"\n puts \"#{@active_player.name}, you've run out of lives.\\nYou're RIGHT DEAD.\\n\\n\"\n switch_player!\n puts \"#{@active_player.name}, you had #{@active_player.lives} #{(@active_player.lives) == 1 ? \"life\" : \"lives\"} remaining and survived for #{(@which_round / 2).to_i} rounds, which means YOU WIN!\\n... By which we mean, you didn't die.\\nRight now.\\n\\nGood...\\n\\n\\n\"\n end",
"def exit(state_manager, game)\n exiting = true\n end",
"def end_game\n @state = 'stop'\n @winner = true\n get_winning_player\n puts \"================ ===================== ===================\"\n puts \"-------------------- GAME OVER! ______________________________________\"\n puts \"____________________ WINNER: #{get_winning_player.try(:name)} --------------------------\"\n puts \"================ ===================== ===================\"\n # write stats/scores to dB ...\n end",
"def end_battle(result=0)\n clear_tr_sprites\n @spriteset.update\n RPG::BGM.fade(400) \n BattleManager.battle_end(result)\n @battle_exiting = result\n @cursor.active = false \n clean_up_battle\n if result == 2 and BattleManager.can_lose? == true\n SceneManager.return #return to map\n end\n end",
"def finalize\r\n push_game_state(Main) # switch to game state \"Menu\"\r\nend",
"def actions_when_game_is_lost\n puts \"\"\n puts \"GAME OVER\".red\n self.quit_game = true\n end",
"def run\n start_game\n game_loop\n end_game\n end",
"def exit_game\n puts \"Goodbye!\"\nend",
"def battle_end(result)\n if result == 2 and not $game_troop.can_lose\n call_gameover\n else\n Graphics.fadeout(30)\n\n if result == 1 && !VICTORY_CONFIG::LOOT_ON_RUN\n $scene = Scene_Victory.new(nil)\n else\n $scene = Scene_Victory.new($game_troop)\n end\n $game_party.clear_actions\n $game_party.remove_states_battle\n $game_troop.clear\n if $game_temp.battle_proc != nil\n $game_temp.battle_proc.call(result)\n $game_temp.battle_proc = nil\n end\n end\n $game_temp.in_battle = false\n end",
"def battle_end(result)\n if result == 2 and not $game_troop.can_lose\n call_gameover\n else\n Graphics.fadeout(30)\n\n if result == 1 && !VICTORY_CONFIG::LOOT_ON_RUN\n $scene = Scene_Victory.new(nil)\n else\n $scene = Scene_Victory.new($game_troop)\n end\n $game_party.clear_actions\n $game_party.remove_states_battle\n $game_troop.clear\n if $game_temp.battle_proc != nil\n $game_temp.battle_proc.call(result)\n $game_temp.battle_proc = nil\n end\n end\n $game_temp.in_battle = false\n end",
"def end_of_game_logic\n check_and_manage_winner\n show_winner_and_scores\n new_round?\n end",
"def quit\n Rubygame.quit()\n exit\n end",
"def quitGame ()\n\nend",
"def main_end\r\n # If switching to title screen\r\n if $scene.is_a?(Scene_Title)\r\n # Fade out screen\r\n Graphics.transition\r\n Graphics.freeze\r\n end\r\n end",
"def end\n if is_still_ongoing? == false\n if @human_player.life_points > 0\n puts \"Bravo tu as gagné la game, t'es fooooort\"\n else\n puts \"t'es nul à chier frère\"\n end #fin if pour Victoire ou défaite\n end #fin premier if\n end",
"def command_shutdown\r\n # Play decision SE\r\n $game_system.se_play($data_system.decision_se)\r\n # Fade out BGM, BGS, and ME\r\n Audio.bgm_fade(800)\r\n Audio.bgs_fade(800)\r\n Audio.me_fade(800)\r\n # Shutdown\r\n $scene = nil\r\n end",
"def end_game\n\t\tputs \"Thank you for playing the Secret Number Game, #{@player}.\"\n\tend",
"def finish\n\t\t@frame = @frame + 1\n\t\tdone = false\n\t\tif @frame % 120 == 0 \n\t\t\tdone = [email protected]\n\t\tend\n\t\tif done\n\t\t\t@frame = 0\n\t\t\t@nextGameState = @map\n\t\telse\n\t\t\[email protected]\n\t\tend\n\tend",
"def finish_game\n\t\tif @check_mate_on == true\n\t\t\tputs \"\\n#{@current_player.name} (#{@current_player.color}) is in CHECKMATE !!!\\n#{@opponent_player.name} (#{@opponent_player.color})WON the game !!!\"\n\t\t\texit\n\t\tend\n\tend",
"def game_finished\n\tif @skip == true\n \t@game_finished = true\n end\nend",
"def end \n \tif @human_player.life_points == 0\n\t\tputs \" Looser tu as perdu...\"\n\t\telsif @enemies.empty? == true\n\t\tputs \"__________________________________\"\n\t\tputs \" VICTOIRE !!! $$$$ \"\n\t\tputs \" ___________________________________\"\n\t\tend\n\tend",
"def main_loop\n# Set up the objects the main loop will\n# need.\n\n# The screen is the window displayed on the\n# screen.\nscreen = Screen.new [640, 480]\n\n# The event queue handles events from the\n# operating system\nqueue = EventQueue.new\n\n# The clock limits the framerate to 30fps\nclock = Clock.new\nclock.target_framerate = 30\n\n# This is the infinite main loop\nloop do\n# Pause the program for a short amount of\n# time so it doesn't exceed 30fps\nclock.tick\n\n# Process all events, return if the window\n# was closed\nqueue.each do|e|\nreturn if e.is_a? QuitEvent\nend\n\n# Fill the screen with a grey color and\n# display it on the monitor\nscreen.fill [200, 200, 200]\nscreen.update\nend\n\nensure\nRubygame.quit\nend",
"def command_shutdown\n Sound.play_decision\n RPG::BGM.fade(800)\n RPG::BGS.fade(800)\n RPG::ME.fade(800)\n $scene = nil\n end",
"def main_end\r\n super\r\n # Execute transition\r\n Graphics.transition(40)\r\n # Prepare for transition\r\n Graphics.freeze\r\n # If battle test\r\n if $BTEST\r\n $scene = nil\r\n end\r\n end",
"def battle_end(result)\n # Clear in battle flag\n $game_temp.in_battle = false\n # Clear entire party actions flag\n $game_party.clear_actions\n # Remove battle states\n for actor in $game_party.actors\n actor.remove_states_battle\n end\n # Clear enemies\n $game_troop.enemies.clear\n # Call battle callback\n if $game_temp.battle_proc != nil\n $game_temp.battle_proc.call(result)\n $game_temp.battle_proc = nil\n end\n # Switch to map screen\n $scene = Scene_Map.new\n end",
"def battle_end(result)\n Game_Temp.in_battle = false\n Game_Temp.current_troop = -1\n extender_end(result)\n end",
"def battle_end(result)\r\n # Clear in battle flag\r\n $game_temp.in_battle = false\r\n # Clear entire party actions flag\r\n $game_party.clear_actions\r\n # Remove battle states\r\n for actor in $game_party.actors\r\n actor.remove_states_battle\r\n end\r\n # Clear enemies\r\n $game_troop.enemies.clear\r\n # Call battle callback\r\n if $game_temp.battle_proc != nil\r\n $game_temp.battle_proc.call(result)\r\n $game_temp.battle_proc = nil\r\n end\r\n # Switch to map screen\r\n $scene = Scene_Map.new\r\n end",
"def end_game\n puts \"------------------ GAME OVER -----------------\"\n puts @player1.is_dead? ? \"Player 2 wins with a score of #{@player2.lives}/3\" : \"Player 1 wins with a score of #{@player1.lives}/3\"\n puts \"Good bye!\"\n end",
"def command_endgame\r\n # Switch to end game screen\r\n $scene = Scene_End.new\r\n end",
"def finishGame\n if @roundsWon > @roundsLost\n puts \"You won the game!\"\n @gamesWon += 1\n else\n puts \"You lost the game :(\"\n @gamesLost += 1\n end\n puts \"Games Won: #{@gamesWon}. Ganes Lost: #{@gamesLost}\"\n requestNewGame()\n end",
"def game_loop\n again = true\n\n while again\n bet\n deal\n player_action\n dealer_action\n reveal_final_hand\n print_player_outcomes\n remove_players\n\n again = play_again?\n linebreak\n end\n\n exit_message\n\n end",
"def exit_game\n print clear_screen, \"\\n\"\n print \"\\\"What business is it of yours where I'm from, friendo?\\\"\", \"\\n\"\n print '-- Anton Chigurh : No Country for Old Men', \"\\n\\n\"\n throw :exit\n end",
"def end_run(run_status)\n # Abstract\n end",
"def end_run(run_status)\n # Abstract\n end",
"def end\n end",
"def end_of_game\n\t\tputs \"\"\n\t\tputs \"Would you like to play again? [Y]es or [N]o\"\n\t\tinput = gets.chomp.upcase\n\t\tif input == 'Y'\n\t\t\tclear_screen\n\t\t\tinitialize\n\t\telsif input == 'N'\n\t\t\tabort(\">Exiting game<\")\n\t\telse\n\t\t\terror\n\t\t\tend_of_game\n\t\tend\n\tend",
"def quit\n Gamework::App.quit\n end",
"def end_game_codebreaker\n if @won\n puts 'Congratulations! You win!'\n else\n puts \"Better luck next time! The code was #{@mastermind_code}.\"\n @computer_score += 1\n end\n # Give some time for the player's response\n sleep(1)\n end",
"def main_loop\r\n Graphics.update # Update game screen\r\n Input.update # Update input information\r\n main_update # Update scene objects\r\n update # Update Processing\r\n end",
"def main\r\n welcome\r\n process_cmd_line\r\n top_up_players\r\n\r\n play_game\r\n\r\n rescue Interrupt\r\n puts\r\n end",
"def end() end",
"def end_of_game\n\t\tputs \"\"\n\t\tif @guess_counter == 0\n\t\t\tputs \"Sorry, but you are out of guesses!\"\n\t\t\tputs \"The answer is '#{@answer_array.join}'\"\n\t\telse\n\t\t\tputs \"Yes! You are correct! The answer is '#{@answer_array.join}'!\"\n\t\t\tputs \"Good job!\"\n\t\tend\n\tend",
"def main_end ; end",
"def at_exit\n\n\t\tend",
"def shutdown\n @gameLoop.stop\n @soundManager.shutdown\n end",
"def check_game_end\n game_end(@@board)\n end",
"def end_game_codemaker\n if @won\n puts 'Congratulations! You chose a really difficult code!'\n @player_score += 1\n else\n puts 'Better luck next time!'\n puts \"The computer was able to guess #{@mastermind_code} in #{@turn} turn#{@turn == 1 ? '' : 's'}.\"\n end\n # Give some time for the player's response\n sleep(1)\n end",
"def endgame()\n\t\t@database = Database.new\n\t\[email protected]_files(@players)\n\t\[email protected]_files\n\tend",
"def main_end\n super\n $game_temp.last_menu_index = @index\n end",
"def end_game\n\t\tputs \"=========================================================================\"\n\t\tputs \"Game Over ... \\n#{@trader.name}, your total value is: #{@trader.value}.\\n\"\n\t\ttotal_profit = @trader.value.to_f - @starting_cash.to_f\n\t\ttotal_return = 100*((total_profit / @starting_cash))\n\t\tputs \"Your final Profit & Loss account is #{total_profit}.\"\n\t\tputs \"Your return was #{total_return}%\"\n\n\t\toutput = case total_return.to_i \n\t\t\twhen 10..25 then \"Wow... you made a lot of money! You're a SuperStar!\"\n\t\t\twhen 5..9 then \"Nice work... BMW or Mercedes?\"\n\t\t\twhen 1..4 then \"Ok... well at least you didn't lose any money\"\n\t\t\twhen -4..0 then \"You're a Loser!\"\n\t\t\twhen -9..-5 then \"You're in deep... I know a good estate agent..\"\n\t\t\telse \"Remember.. this is just a game!!!!\"\t\n\t\tend\n\t\tputs \"#{@trader.name} ... #{output}\"\n\tend",
"def end_game_message(message)\nsystem \"clear\"\nputs \"GAME OVER: #{ message }\"\nlaat_bord_zien\nend",
"def game_end\n if @board.win?\n puts \"\\nBravo ! #{@current_player.name} a gagné ! \"\n else\n puts \"\\nC'est une égalité !\"\n end\n @status = \"game end\"\n\n # Suggests another round\n puts \"Souhaitez-vous refaire une partie ? (o/n)\"\n choice = gets.chomp\n if choice == \"o\"\n new_round\n else\n puts \"A bientôt !\"\n end\n end",
"def ending_screen\n if @winner == @player1\n color = :red\n elsif @winner == @player2\n color = :blue\n else\n color = :green\n end\n puts\n puts \"The game is finished.\"\n if @winner.nil?\n puts \"The game is a draw!\".colorize(color)\n else\n puts \"#{@winner.name} wins the game!\".colorize(color)\n end\n puts\n puts \"Would you like to play again? (Y/N)\"\n print \">> \"\n response = gets.chomp\n reset_board if response.downcase == \"y\"\n end",
"def end_of_game bridge\n if bridge != 0\n puts \"replay\"\n else\n puts \"game over\"\n end\nend",
"def end\n end",
"def stopping; end",
"def end_frame\n end",
"def end_screen(player)\r\n puts \" ----------------------- \"\r\n puts \"\"\r\n puts \" -- La partie est finie --\"\r\n puts \"\"\r\n puts \" ----------------------- \"\r\n puts \"\"\r\n if player.life_points > 0\r\n puts \"Félicitations, Vous remportez la partie !\"\r\n puts \"\"\r\n puts \" ----------------------- \"\r\n else\r\n puts \"Dommage, Vous avez perdu la partie !\"\r\n puts \"\"\r\n puts \" ----------------------- \"\r\n end\r\nend",
"def close\r\n pop_game_state\r\n end",
"def finish\r\n #\r\n end",
"def run_script\n\tgame = GameController.new\n\tsystem \"clear\"\n\tputs GameController.welcome_message.blue\n\tsleep 2\n\tsystem \"clear\"\n\t# puts GameController.bulletin_board\n\tgame.array_of_teams\n\tgame.choose_team\n\tgame.favorite_team\n\tgame.favorite_team_id\n\tgame.random_rival\n\tgame.get_rival_id\n\t\nend",
"def on_game_pause_end\n # Set Game Paused Flag & Graphics Frame Count\n @game_paused = false ; Graphics.frame_count = @pause_frame_count\n end",
"def end_game\n self.update_attribute(:finished, true)\n\n s1 = 0\n s2 = 0\n for pw in self.playedWords\n if (pw.player == self.players[0])\n s1 += pw.word.length\n else\n s2 += pw.word.length\n end\n end\n if (s1 > s2)\n players[0].addVictory\n elsif (s1 < s2)\n players[1].addVictory\n end\n end",
"def runner\n welcome\n game = initial_round\n until game > 21 do\n game = hit?(game)\n display_card_total(game)\n end\nend_game(game)\nend",
"def force_end\n stop\n end",
"def main\n\t\tstart\n\t\twhile self == SceneManager.scene\n\t\t\tGraphics.update\n\t\t\tController.keyboard.update\n\t\t\tupdate\n\t\t\tController.wait_next_frame\n\t\tend\n\t\tterminate\n\tend",
"def leave; end",
"def quit(msg)\n if @started\n msg.reply('Game exited.'.freeze)\n @started = false\n @random_number = nil\n @tries = nil\n else\n msg.reply('There is not game to exit.'.freeze)\n end\n end",
"def play\n \t@fragment = \"\"\n until @losses.keys.length == 1\n system(\"clear\")\n update_status\n play_round\n check_status\n puts \"Next round in 5 seconds...\".bold\n sleep(5)\n end\n final_status\n end",
"def idle\n gateway_check\n update_status((Time.now.to_f * 1000), @game, nil)\n end",
"def finish\n noth\n end",
"def displayEndgame\n \tputs \"\\e[#{SCREEN_Y+1};#{1}HGame over.\\e[#{SCREEN_Y+2};#{1}H\"\nend",
"def process\n finish_games\n level_up\n warn_level_up\n start_games\n end",
"def perform \n application = Application.new\n while application.decide == \"Y\"\n application.ongoing_game\n application.ending_game \n end\nend",
"def end_game\n sleep 1\n self.stop = true\n winer = if ((21 - user.hand.total_score) < (21 - dealer.hand.total_score)) && (user.hand.total_score <= 21)\n user.name\n elsif (dealer.hand.total_score <= 21) && (user.hand.total_score <= 21) && (user.hand.total_score == dealer.hand.total_score)\n 'Ничья!'\n elsif dealer.hand.total_score <= 21\n dealer.name\n elsif user.hand.total_score <= 21\n user.name\n else\n 'Все проиграли!'\n end\n interface.show_winner(winer)\n interface.show_user_cards(user)\n interface.show_open_dealer_cards(dealer)\n update_bank(winer)\n end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def stop; end",
"def game_handler\n\t\twhile @guesses_remaining > -1\n\t\t\tdisplay_game\n\t\t\t# Check for win condition here to properly display when we're out of guesses.\n\t\t\tif (game_finished?)\n\t\t\t\tend_game\n\t\t\tend\n\t\t\tmake_turn\n\t\tend\n\tend"
] | [
"0.7868033",
"0.7835601",
"0.7824509",
"0.7634437",
"0.7603135",
"0.7529829",
"0.7408827",
"0.73540515",
"0.7340615",
"0.7283339",
"0.7239709",
"0.7217348",
"0.7120029",
"0.7067559",
"0.70627016",
"0.7003624",
"0.6978254",
"0.69382876",
"0.6924994",
"0.69168586",
"0.6909244",
"0.6874854",
"0.68687105",
"0.6865029",
"0.6854659",
"0.6782834",
"0.67827237",
"0.67827237",
"0.67714065",
"0.67324346",
"0.6715391",
"0.67101943",
"0.6701895",
"0.6660229",
"0.66556734",
"0.66469467",
"0.6639222",
"0.6632778",
"0.6605578",
"0.65686506",
"0.65665275",
"0.6564954",
"0.65582234",
"0.65553826",
"0.65467703",
"0.6545093",
"0.6537096",
"0.6535779",
"0.6508888",
"0.64976287",
"0.6497102",
"0.6497102",
"0.649706",
"0.6488206",
"0.64857167",
"0.6476577",
"0.64721936",
"0.6464574",
"0.6458967",
"0.64495575",
"0.64484257",
"0.64374",
"0.6400028",
"0.63930225",
"0.63920385",
"0.6390282",
"0.63890445",
"0.63818127",
"0.6380488",
"0.637498",
"0.63580745",
"0.63531446",
"0.6350539",
"0.63483393",
"0.63357544",
"0.6314887",
"0.6311322",
"0.63045996",
"0.6289785",
"0.62848717",
"0.628309",
"0.62741584",
"0.6238056",
"0.62337446",
"0.6228074",
"0.6227958",
"0.62277675",
"0.6226182",
"0.62181187",
"0.6218111",
"0.6216935",
"0.62156487",
"0.6210649",
"0.6205856",
"0.6205856",
"0.6205856",
"0.6205856",
"0.6205856",
"0.6205856",
"0.6205856",
"0.6199968"
] | 0.0 | -1 |
Shows list of Players (for admin). ==== Format HTML | def index
@players = Player.all
respond_to do |format|
format.html # index.html.erb
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @pmplayers = Pmplayer.all\n end",
"def index\n @players = Player.all\n\n respond_to do |format|\n format.html # index.html.haml\n format.json { render json: @players }\n end\n end",
"def show\n @players = @team.players\n end",
"def list_all_players\n json_output = Player.all.map do |player|\n {\n id: player.id,\n name: player.name,\n image_url: player.image_url,\n }\n end\n\n render :json => json_output\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n end",
"def index\n @players = Player.all\n # \"Player.all\" sends message to the Player model to retrieve all the Player instances\n # that list of players is assigned to @players\n # @players is available in the view to display all players or specific players\n end",
"def index\n @players = Player.all\n # @player = current_user.players\n end",
"def index\n @players = Player.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players }\n end\n end",
"def show\n @players = Player.where(team: @team)\n end",
"def index\n @players_prizes = PlayersPrize.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players_prizes }\n end\n end",
"def players\n\t\t@content_title = \"Players\"\n\tend",
"def index\n @players = Player.order(:id)\n end",
"def index\n @players = Player.all\n render json: @players, status: 200\n end",
"def index\n @team_players = TeamPlayer.all\n end",
"def index\n @players = Player.all\n auth!\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @players }\n end\n end",
"def index\n respond_to do |format|\n format.html\n format.json { render json: PlayersDecorator.new(Player.all).all_data }\n end\n end",
"def index\n @players = Player.all\n render json: @players\n end",
"def index\n @players = @game.players\n end",
"def index\n @players = @game.players\n end",
"def index\n @drafted_players = DraftedPlayer.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @drafted_players }\n end\n end",
"def index\n @players = Player.all\n @players = Player.all.paginate(page: params[:page], per_page: 5)\n end",
"def index\n @group_players = GroupPlayer.all\n end",
"def index\n @players = Player.includes(:team).order('last_name, first_name').paginate(:page=>params[:page], :per_page =>20)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players }\n end\n end",
"def index\n @team = Team.find(params[:team_id])\n @players = @team.players\n end",
"def index\n player = Player.all\n render json: players, status: 200\n end",
"def index\n @teams_players = TeamsPlayer.all\n end",
"def index\n @players = Player.find(:all, :order => 'lname')\n\n respond_to do |format|\n format.html # index.rhtml\n format.xml { render :xml => @players.to_xml }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @players_prize }\n end\n end",
"def index\n @players = Player.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @players }\n end\n end",
"def index\n @players = Player.page params[:page]\n\t respond_with(@players)\n end",
"def index\n @player_profiles = PlayerProfile.all\n end",
"def index\n @players = @tournament.players\n end",
"def index\n\t\t@game = Game.find(params[:game_id])\n\t\t@players = @game.players\n\n\t\trespond_to do |format|\n\t\t\tformat.html # index.html.erb\n\t\t\tformat.xml { render :xml => @players }\n\t\tend\n\tend",
"def index\n @fantasy_players = FantasyPlayer.all\n end",
"def show\n @all_player = AllPlayer.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @all_player }\n end\n end",
"def index\n collection = if request.query_parameters.present?\n Player.where request.query_parameters\n else\n Player.all\n end\n\n @players = collection.order 'first_name'\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players.to_json(only: public_attrs) }\n end\n end",
"def index\n @game_players = GamePlayer.all\n end",
"def showlist\n\t\t@people_list.each do |x|\n\t\t\tputs \"* #{capitalize(x.type)}, #{capitalize(x.name)}, #{capitalize(x.party)}\"\n\t\tend\n\tend",
"def index\n @pitchers = Pitcher.all.order('name ASC').paginate(:page => params[:page], :per_page => 10)\n end",
"def index\n @players = Player.all\n @teams = Team.all\n end",
"def show_players\n @game.players.map do |gamer|\n colorize_nick(gamer)\n end.join ', '\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.haml\n format.json { render json: @player }\n end\n end",
"def show\n set_lobby\n @champions = Champion.all\n end",
"def index\n @leagueplayers = Leagueplayer.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @leagueplayers }\n end\n end",
"def players(demo_id = nil)\n get_records \"player\", demo_id ? \"/demos/#{demo_id}/players\" : \"/players\"\n end",
"def index\n puts params.inspect\n @api_players = Player.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @api_players }\n end\n end",
"def show_players\n puts @cards.length\n @players.each do |player|\n puts \"Nombre: #{player.name}\"\n player.cards.each do |card|\n puts card.id\n end\n end\n end",
"def show\n # before_action\n @games = @player.games\n end",
"def index\n @player_records = PlayerRecord.all\n end",
"def show\n\n \t\t\trespond_with @player\n\n \t\tend",
"def show\n @player = Player.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def show\n @team = Team.find(params[:team_id])\n @player = @team.players.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @player }\n end\n end",
"def index\n @game_session_players = GameSessionPlayer.all\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player.to_json(only: public_attrs) }\n end\n end",
"def index\n @attribute_players = AttributePlayer.all\n end",
"def index\r\n authorize! :index, Player\r\n @operation_players = Operation::Player.accessible_by(current_ability, :read).includes(:player_group)\r\n @operation_players = @operation_players.search(params[:search]) unless params[:search].blank?\r\n @operation_players = @operation_players.where(player_group_id: params[:player_group_id]) unless params[:player_group_id].blank?\r\n @operation_players = @operation_players.order(\"#{sort_column} #{sort_direction}\") unless sort_column.blank?\r\n @operation_players = @operation_players.paginate(page: params[:page], per_page: params[:per_page] || 100)\r\n end",
"def show\n respond_to do |format|\n format.json { render json: @player }\n end\n end",
"def index\n @players = Player.order(:gamertag_lower).all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players }\n end\n end",
"def index\n @players = Player.search(params[:team_id], params[:player_forename], params[:player_surename])\n\n respond_to do |format|\n format.html # index.html.erb\n hash = {:players => @players}\n format.json { render :json => hash }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def index\n \n @players = smart_listing_create :players, \n Player.active_players.text_search(params[:query]), \n partial: \"players/players_info_fields\", \n default_sort: {last_name: \"asc\"}, \n page_sizes: [25, 50, 100, 500]\n \n @players_download = Player.active_players.order(:last_name)\n \n if current_user\n # gon.current_user_draft_rosters = DraftRoster.where(\"team_id = ?\", current_user.team.id) unless @players.empty?\n @draft_rosters = current_user.team.draft_rosters\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @players }\n format.csv { send_data Player.to_csv(@players_download) }\n format.js\n format.xls\n end\n end",
"def display_partners\n\t\t# get an aggregate query of necessary info for the partnerships and their most recent encounter\n\t\tp_sorted = current_user_profile.partners_with_most_recent\n\t\tagg = p_sorted.map do |ship|\n\t\t\t# make a list item\n\t\t\tcontent_tag(:li, {class: \"button-list__item\"}) do\n\t\t\t\t# link to that partnership's show page\n\t\t\t\tlink_to(partnership_path(ship[\"_id\"]), class: 'cta cta--is-square partnership-link') do\n\t\t\t\t\tdisplay_partner(ship)\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t# join and nest\n\t\tcontent_tag(:ul, safe_join(agg), {class: \"button-list container--has-centered-child__centered-child\"})\n\tend",
"def get_players\n\n end",
"def show\n render json: @player\n end",
"def show_flops\n players.each do |player|\n player.display_flop\n end\n end",
"def show\n param! :order, String, in: %w(asc desc), transform: :downcase, default: 'desc'\n param! :sort, String, in: Player.sort_allowed?, default: Player.sort_default\n param! :limit, Integer, in: (10..100), default: 25\n param! :page, Integer, default: 1\n param! :search, String, default: nil\n param! :countryId, String, default: nil\n\n @scope = Player.where(hideranking: 0)\n end",
"def index\n @playlists = Playlist.all\n end",
"def players(list=\"all\")\n\t\t\t\tdata = send(['listPlayers', list])\n\t\t\t\tif data\n\t\t\t\t\treturn Player.players_from_list(data,0)\n\t\t\t\tend\n\t\t\tend",
"def index\n @players = Player.all\n # handle search parameter\n if params[:search].present?\n @players = @players.search(params[:search])\n if @players.empty?\n flash.now[:alert] = t('flash.alert.search_players')\n end\n end\n # handle sort parameter\n sort = params[:sort]\n if sort.present?\n case sort\n when 'win_loss_ratio'\n if params[:order] == \"desc\"\n @players = @players.sort_by do |p|\n [p.win_loss_ratio, -p.created_at.to_i]\n end.paginate(page: params[:page], per_page: Player::MAX_PLAYERS_PER_PAGE)\n else\n @players = @players.sort_by do |p|\n [p.win_loss_ratio, -p.created_at.to_i]\n end.reverse.paginate(page: params[:page], per_page: Player::MAX_PLAYERS_PER_PAGE)\n end\n else\n @players = @players.order(\"players.?\".gsub('?', params[:sort])).paginate(page: params[:page], per_page: Player::MAX_PLAYERS_PER_PAGE)\n end\n else\n @players = @players.order(created_at: :desc).paginate(page: params[:page], per_page: Player::MAX_PLAYERS_PER_PAGE)\n end\n # handle the order parameter\n if params[:order] == \"desc\" and [email protected]_a?(Array)\n @players = @players.reverse_order\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n render :json => @player\n end",
"def index\n @paddle_games = PaddleGame.all\n end",
"def index\n @players = Player.order 'lower(name)'\n render json: @players, serializer: V1::ApplicationArraySerializer\n end",
"def players\n users\n end",
"def index\n players=Player.all\n render json: players, include: [:player_items=>{include:[:item]}, :player_skills=>{include:[:skill]}], except: [:created_at, :updated_at], methods: [:adjusted_stats, :equipped_items, :consumables]\n end",
"def show\n @players_on_football_field=@user_team.players_on_football_field\n @first_team_goalkeeper=@user_team.user_team_players.first_team_goalkeeper[0].player\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html {\n @buttons = [\n { :body => I18n.t(\"messages.players.form.back_to_list\"), :url => players_path, :html_options => {} }\n ]\n }\n end\n end",
"def index\n @current_user.copy_fields_from_facebook if @current_user.name.blank?\n\n # listing all games within selected player\n @games = @player.games\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @games }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.rhtml\n end\n end",
"def index\n @player_roles = PlayerRole.all\n end",
"def list\n puts '》 PLAYLIST 《'\n empty if @playlist.empty?\n rows = @playlist.map { |track| [track['name'], track['artist']] }\n table = Terminal::Table.new headings: %w[Track Artist], rows: rows\n puts table\n keypress_playlist\n menu\n end",
"def player\n fetch('football.players')\n end",
"def index\n listing_games\n end"
] | [
"0.71804583",
"0.71802056",
"0.7094666",
"0.70259684",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69779086",
"0.69267803",
"0.69240576",
"0.683259",
"0.68240416",
"0.6757607",
"0.67270035",
"0.67247",
"0.67075324",
"0.66913086",
"0.6675604",
"0.66457397",
"0.6644631",
"0.6622336",
"0.6622336",
"0.66211724",
"0.66147304",
"0.65915793",
"0.6574629",
"0.65307504",
"0.6513283",
"0.65000963",
"0.6489751",
"0.6487499",
"0.6484025",
"0.6464737",
"0.64641654",
"0.64630985",
"0.64627206",
"0.6457246",
"0.6455238",
"0.64374614",
"0.63795036",
"0.62778175",
"0.62570256",
"0.62340003",
"0.62309086",
"0.6187739",
"0.6175258",
"0.61621356",
"0.61565113",
"0.61483204",
"0.6142741",
"0.61055565",
"0.6105377",
"0.6099183",
"0.60953665",
"0.6091837",
"0.6084294",
"0.6082564",
"0.60807765",
"0.6080252",
"0.60647136",
"0.6027236",
"0.6026715",
"0.6005178",
"0.60044956",
"0.60044956",
"0.60044956",
"0.60044956",
"0.60044956",
"0.59973574",
"0.59966063",
"0.59935635",
"0.5985825",
"0.5983475",
"0.5976012",
"0.5967947",
"0.5966448",
"0.5957499",
"0.5932745",
"0.5924404",
"0.5914234",
"0.59138256",
"0.5910048",
"0.59087294",
"0.5906394",
"0.5904219",
"0.59005886",
"0.58956295",
"0.58932906",
"0.5890947",
"0.5890106"
] | 0.7079668 | 3 |
Shows detail of _Player_ (for admin). ==== Required params _id_:: id of _Player_ that should be shown. ==== Format HTML | def show
@player = Player.find(params[:id])
respond_to do |format|
format.html # show.html.erb
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n @player = Player.find(params[:id])\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.haml\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.rhtml\n end\n end",
"def show\n\t\t@player = Player.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # show.html.erb\n\t\t\tformat.xml { render :xml => @player }\n\t\tend\n\tend",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n if request.xhr?\n render @player\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n render :json => @player\n end",
"def show\n @player = Player.includes(:team).find(params[:id])\n end",
"def show\n respond_with Player.find(params[:id])\n end",
"def show\n @player = Player.find(params[:id])\n @page_title = \"Meet #{@player.full_name}\"\n \n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def show\n @all_player = AllPlayer.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @all_player }\n end\n end",
"def show\n @player_record = PlayerRecord.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_record }\n end\n end",
"def show\n\n \t\t\trespond_with @player\n\n \t\tend",
"def edit\n @player = Player.find(params[:id])\n end",
"def show\n @team = Team.find(params[:team_id])\n @player = @team.players.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @player }\n end\n end",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player.to_json(only: public_attrs) }\n end\n end",
"def show\n # find the player by their login\n @player = Player.find_by_login(params[:id])\n # 404 if player isn't found\n raise ActiveRecord::RecordNotFound unless @player\n end",
"def edit\n # @player = Player.find(params[:id])\n end",
"def show\n @playerdiv = Playerdiv.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @playerdiv }\n end\n end",
"def show\n @player = Player.find(params[:id])\n @team\n if params[:team_id]\n @team = Team.find(params[:team_id])\n end \n \n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def show\n @player_id = params[:player_id].to_i # TODO: With Devise, this would be @current_user.id\n end",
"def show\n @game_player = GamePlayer.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @game_player }\n end\n end",
"def show\n @client_player = ClientPlayer.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @client_player }\n end\n end",
"def show\n @players = @team.players\n end",
"def show\n if session[:user_id].nil?\n flash[:error] = \"Please log in.\"\n redirect_to '/'\n return\n end\n\n if session[:user_id].to_i != params[:id].to_i\n redirect_to '/nope' unless Player.find(params[:id]).tagged\n return\n end\n @player = Player.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player = Player.new\n end",
"def show\n respond_with @player\n end",
"def show\n respond_to do |format|\n format.html { @player = Player.find(params[:id]) }\n format.json { render json: Player.find(params[:id]).as_json(:include => [:items, :spells]) }\n end\n end",
"def player_name(id)\n name = Player.find(id)\n end",
"def show\n respond_to do |format|\n format.json { render json: @player }\n end\n end",
"def show\n @player_statistic = PlayerStatistic.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_statistic }\n end\n end",
"def show\n @leagueplayer = Leagueplayer.find(params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @leagueplayer }\n end\n end",
"def show_player(name)\n if player = Player.find_by_name(name)\n puts \"____________________________________________________________________\"\n puts \"#{player.player} Age:#{player.age} Position:#{player.position}\"\n puts \"Team:#{player.team}\"\n puts \"Games Played: #{player.games_played}\"\n puts \"Goals: #{player.goals}\"\n puts \"Assists: #{player.assists}\"\n puts \"Points: #{player.points}\"\n puts \"Shooting Percentage: #{player.shooting_percentage}\"\n puts \"Plus Minus: #{player.plus_minus}\"\n puts \"Penalty Minutes: #{player.penalty_minutes}\"\n puts \"Average TOI: #{player.toi_avg}\"\n puts \"Blocks: #{player.blocks}\"\n puts \"Hits: #{player.hits}\"\n puts \"Faceoff Percentage: #{player.faceoff_percentage}\"\n puts \"____________________________________________________________________\"\n else\n raise_player_error\n end\n end",
"def show\n scope = jsonapi_scope(Streak.where(id: params[:id]))\n logger.info \"#{\"*\"*80}IN THE STREAKS CONTROLLER This Here are the team_players: #{instance.team_players.map(&:color).join(\",\")}\"\n instance = scope.resolve.first\n raise JsonapiCompliable::Errors::RecordNotFound unless instance\n render_jsonapi(instance, scope: false)\n end",
"def show\n @games_player = GamesPlayer.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @games_player }\n end\n end",
"def show\n @player_game = PlayerGame.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @player_game }\n end\n end",
"def player(player_id)\n path = ['shards', @region, 'players', player_id].join('/')\n get(path)\n end",
"def edit\n @player = Player.find(params[:id])\n \n respond_to do |format|\n format.html {\n @buttons = [\n { :body => I18n.t(\"messages.players.form.back_to_detail\"), :url => @player , :html_options => {} },\n { :body => I18n.t(\"messages.players.form.back_to_list\"), :url => players_path, :html_options => {} }\n ]\n }\n end\n end",
"def show\n @player_game_stat = PlayerGameStat.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_game_stat }\n end\n end",
"def show\n if params.has_key? :screen_id\n screen_id = params[:screen_id]\n @player = ConcertoHardware::Player.find_by_screen_id!(screen_id)\n elsif params.has_key? :id\n @player = Player.find(params[:id])\n else # Return data about the logged-in screen\n if current_screen.nil?\n raise ActiveRecord::RecordNotFound, \"Couldn't find an authenticated screen.\"\n else\n @player = Player.find_by_screen_id!(current_screen.id)\n @player.ip_address = request.remote_ip if @player\n end\n end\n auth!\n\n @player.save if @player.ip_address_changed?\n\n respond_to do |format|\n format.html # show.html.erb\n format.json {\n render :json => @player.to_json(\n :include => { :screen => { :only => :name } },\n :methods => [:time_zone]\n )\n }\n end\n end",
"def show\n @player_challenge = PlayerChallenge.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @player_challenge }\n end\n end",
"def show\n @player_client = PlayerClient.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_client }\n end\n end",
"def show\n\t\t\t\"nothing to show for id - #{params[:id]} - with parameters: #{params.to_s}\"\n\t\tend",
"def show\n @players = Player.where(team: @team)\n end",
"def show\n @player = Player.where(:uuid => params[:uuid]).first\n if @player\n render :json => { :success => true, :player => @player }\n else\n render :json => { :success => false, :player => {} } , :status => 404\n end\n\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to [:admin, @player], notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n\t\t\"I'd love to show you object with id: #{params[:id]}\"\n\tend",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @player.to_xml(:include => :titles) }\n end\n end",
"def show\n @pending_players = PendingPlayer.where(\"tournament_id = #{params[:id]}\")\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @tournament }\n end\n end",
"def show\n render json: @player, status: 200\n end",
"def show\n @user = User.find(params[:id])\n\n unless @user\n flash[:error] = \"Player not found.\"\n redirect_to users_path\n return\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @user }\n end\n end",
"def show\n id = params[:id] || extract_id_from(params[:encoded_id])\n @playing = Playing.find(id)\n\n respond_to do |format|\n format.html { render locals: { short_url: short_link_to(@playing) } }\n format.json { render json: @playing }\n end\n end",
"def show\n render json: @player\n end",
"def show\n @player_message = PlayerMessage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @player_message }\n end\n end",
"def show\n @player_alias = PlayerAlias.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @player_alias }\n end\n end",
"def show\n @player_loan = PlayerLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_loan }\n end\n end",
"def get_player(id)\n\t\treturn @players[id]\n\tend",
"def show\n @default_player_datum = DefaultPlayerDatum.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @default_player_datum }\n end\n end",
"def show\n @howtoplaygame = Howtoplaygame.find_by_game_id(params[:id])\n end",
"def show\n\t\t@user = User.find(params[:id])\n authorize! :show, @user\n\n # => for related Players\n # => move this to the User Model\n # => make it a single call from the controller to get this information\n @player_ids = UserToPlayer.user_has_players(@user.id)\n player_ids_array = Array.new\n @player_ids.each do |player_ids|\n player_ids_array.push(player_ids.player_id)\n end\n @players = Player.find(player_ids_array)\n\n # => for related Coaches\n @coach = []\n\n\tend",
"def load_player(id)\n load_entity('.player', id)\n end",
"def show\n @player = Player.find(params[:id])\n if @player.games.count >= 1\n @last_team_name = @player.games.find(:last).team_name\n @year = @player.games.first.date.year\n @newest_year = @player.games.last.date.year\n else\n @last_team_name = \"Your team name\"\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player }\n end\n end",
"def show\n @player_round_loan = PlayerRoundLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_round_loan }\n end\n end",
"def show\n @player = params[:username].blank? ? current_player : Player.find_by_username(params[:username])\n\n respond_to do |format|\n if @player\n @ratings = @player.ratings\n authorize! :show, @player\n\n format.html # show.html.erb\n format.json { render json: @player }\n else\n format.html { redirect_to root_url, :alert => 'Profile does not exist.'}\n format.json { render :nothing => true }\n end\n end\n end",
"def show\n @player_investment = PlayerInvestment.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_investment }\n end\n end",
"def show\n @single_song = Song.where(id: params[:id])\n render :show\n end",
"def show\n @tournament = Tournament.find(params[:id])\n end",
"def player(player_id)\n get_request(shard_endpoint_uri(\"players/#{player_id}\"))\n end",
"def show\n @game = Game.where(id: params[:id]).first\n end",
"def show\n @song = Song.find(params[:id])\n render :show\n end",
"def player_by_id(id)\n response = Faraday.get(\"#{URL}/#{id}\")\n data = JSON.parse(response.body)\n new(data[KEY][0]) if data[KEY]\n end",
"def show\n\t\trender plain: params[:id]\n\tend",
"def player_by_id id\n @players.select {|p| p.id == id}.first\n end",
"def show\n @track = Track.find(params[:id])\n render :template => \"tracks/show\"\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end"
] | [
"0.7839618",
"0.78126955",
"0.7735972",
"0.76310664",
"0.7547737",
"0.7348806",
"0.7348806",
"0.7348806",
"0.7348806",
"0.7348806",
"0.7201806",
"0.7195121",
"0.71787214",
"0.7174951",
"0.7112462",
"0.70890814",
"0.70375544",
"0.7010983",
"0.69979554",
"0.69338286",
"0.6933198",
"0.69221836",
"0.691017",
"0.68821496",
"0.68612456",
"0.68516946",
"0.6838409",
"0.6802721",
"0.6767166",
"0.6722305",
"0.6696226",
"0.6626625",
"0.6595972",
"0.6593255",
"0.6587192",
"0.6575668",
"0.6569346",
"0.65512496",
"0.6547572",
"0.65278715",
"0.6523588",
"0.6496243",
"0.6476947",
"0.6455762",
"0.64397997",
"0.643301",
"0.64257723",
"0.64161265",
"0.64120704",
"0.637896",
"0.6366244",
"0.6360701",
"0.63437724",
"0.63329494",
"0.6320524",
"0.63004357",
"0.62989056",
"0.62918586",
"0.6272215",
"0.6268793",
"0.62632793",
"0.62231064",
"0.61988664",
"0.6186101",
"0.61839175",
"0.617193",
"0.6163431",
"0.6151244",
"0.6136978",
"0.61307",
"0.6119452",
"0.61099917",
"0.6105844",
"0.61040026",
"0.6083921",
"0.60824203",
"0.60592514",
"0.6050631",
"0.60495263",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744",
"0.6035744"
] | 0.77347946 | 3 |
Shows form that serves to create new _Player_. ==== Format HTML | def new
@player = Player.new
respond_to do |format|
format.html {
@buttons = [
{ :body => I18n.t("messages.players.form.back_to_list"), :url => players_path, :html_options => {} }
]
}
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n# ToDo 0 => Wenn Spieler erstellt wurde, schließe das Fenster und aktualisiere die Spielerliste bzw. die Spielerübersicht\n format.html { redirect_to home_path, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html {\n redirect_to @player, notice: I18n.t(\"messages.players.create.success\")\n }\n else\n format.html {\n @errors = @player.errors\n render action: \"new\"\n }\n end\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to \"/players/new\", notice: (@player.name + ' was successfully created.') }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to root_path, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to(@player, :notice => 'Player was successfully created.') }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Dodano nowego zawodnika.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.save\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to [:admin, @player], notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n event \"create\", :player, @player.id, description: \"#{current_player.name} created player #{@player.name}\"\n format.html { redirect_to @player, flash: { success: 'Player was successfully created.' } }\n format.json { render json: @player.to_json(only: public_attrs), status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n\t\t# @team = Team.find(params[:team_id]) --see above for assign_team\n\n\t\t# by writing this ..we can connect it in the new form new.html.erb\n\t\t@player = Player.new\n\tend",
"def create\n @player = Player.new(player_params)\n respond_to do |format|\n if @player.save\n EventMailer.new_player(@player).deliver\n format.html { redirect_to page_thank_you_path }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n respond_with @player\n else\n render action: :new\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @player }\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: \"Player was successfully created.\" }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n\t\t@positions = find_positions\n\t\t@teams = find_teams\n respond_to do |format|\n format.html # new.html.erb\n end\n end",
"def new\n @player = Player.new\n end",
"def new\n @player = Player.new\n end",
"def new\n @client_player = ClientPlayer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @client_player }\n end\n end",
"def create\n @player = Player.new(params[:player])\n @player.user_id = current_user.id\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n format.html { redirect_to @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\t\t\n\t\t#finish refactoring this method and view with simple form to get system params in one form\n\t\txbox = PlayersConsole.new(gtag: params[:XBL])\n\t\txbox.player = current_player\n\t\txbox.console_id = XBOX\n\t\txbox.save\n\n\t\tplaystation = PlayersConsole.new(gtag: params[:PSN])\n\t\tplaystation.player = current_player\n\t\tplaystation.console_id = PLAYSTATION\n\t\tplaystation.save\n\n\t\tredirect_to player_show_path(current_player)\n\tend",
"def create\n @player = Player.new(params[:player])\n flash[:notice] = 'Se guardó el nuevo Player.' if @player.save\n respond_with(@player)\n end",
"def create\n @client_player = ClientPlayer.new(params[:client_player])\n\n respond_to do |format|\n if @client_player.save\n format.html { redirect_to @client_player, notice: 'Client player was successfully created.' }\n format.json { render json: @client_player, status: :created, location: @client_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @client_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @team_player = TeamPlayer.new(team_player_params)\n\n respond_to do |format|\n if @team_player.save\n format.html { redirect_to @team_player, notice: 'Team player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @team_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @team_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Api::Player was successfully created.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.user = current_user\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n\t\t@player = Player.new\n\tend",
"def create\n @player = Player.new(params[:player])\n \n if @player.save\n render :json => @player, :status => :created, :location => @player\n else\n render :json => @player.errors, :status => :unprocessable_entity\n end\n end",
"def new\n @player_record = PlayerRecord.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player_record }\n end\n end",
"def create\n @player = Player.new(player_params)\n flash[:notice] = \"Player was created successfully.\" if @player.save\n respond_with @player\n end",
"def create\n @player = Player.new\n @player.playername = params[:playername]\n @player.password = params[:password]\n\n if @player.save\n redirect_to \"/login\"\n else\n render :new\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player.to_json(only: public_attrs) }\n end\n end",
"def new\n @player=Player.find(params[:player_id])\n\n @pnl = Pnl.new\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @pnl }\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n session[:current_player] = @player\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @group_player = GroupPlayer.new(group_player_params)\n\n respond_to do |format|\n if @group_player.save\n format.html { redirect_to @group_player, notice: 'Group player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @group_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @group_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @playerdiv = Playerdiv.new(params[:playerdiv])\n\n respond_to do |format|\n if @playerdiv.save\n format.html { redirect_to @playerdiv, :notice => 'Playerdiv was successfully created.' }\n format.json { render :json => @playerdiv, :status => :created, :location => @playerdiv }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @playerdiv.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @playerdiv = Playerdiv.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @playerdiv }\n end\n end",
"def new\n @player = Player.new\n end",
"def create\n @drafted_player = DraftedPlayer.new(drafted_player_params)\n\n respond_to do |format|\n if @drafted_player.save\n format.html { redirect_to @drafted_player, notice: 'Drafted player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @drafted_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @drafted_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.json { render json: @player, status: :created }\n else\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n puts(params);\n @player = Player.new(player_params)\n \n respond_to do |format|\n if @player.save\n # Tell the playerMailer to send a welcome email after save\n # @user_player = Userplayer.new(user_id: @user.id, player_id: @player_id)\n # if @user_player.save\n @tournament.players << @player\n # @tournament.update_attribute(num_players: @tournament.num_players + 1)\n format.html { redirect_to(root_path, notice: 'player was successfully added.') }\n format.json { render json: @player, status: :created, location: @player }\n # end\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.user = current_user\n # automatically create a new team for the user if there isn't one already\n unless @player.team || @player.name.blank?\n team = Team.find_or_initialize_by(name: \"#{@player.name}'s Team\", code: @player.name.upcase)\n @player.team = team if team.save\n end\n respond_to do |format|\n if @player.save\n format.html { redirect_to(@player, :notice => 'Player was successfully created.') }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n team.destroy if team\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @all_player = AllPlayer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @all_player }\n end\n end",
"def create\n\t\tavatar = Avatar.new(params[:avatar])\n\t\tavatar_saved = avatar.save\n @player = Player.new(params[:player])\n\t\[email protected] = current_user\n\t\tif avatar_saved\n\t\t\[email protected] = avatar\n\t\tend\n\t\tsaved = @player.save\n\t\tflash[:notice] = 'Zawodnik został dodany' if saved\n\t\tcontinue = !params[:continue].nil?\n\t\trespond_to do |format|\n\t\t\tformat.html do\n\t\t\t\tif saved and continue\n\t\t\t\t\tredirect_to new_player_path\n\t\t\t\telsif saved\n \t redirect_to player_path(@player)\n \telse\n \t render :action => \"new\"\n \tend\n\t\t\tend\n end\n end",
"def create\n @teams_player = TeamsPlayer.new(teams_player_params)\n\n respond_to do |format|\n if @teams_player.save\n format.html { redirect_to @teams_player, notice: 'Teams player was successfully created.' }\n format.json { render :show, status: :created, location: @teams_player }\n else\n format.html { render :new }\n format.json { render json: @teams_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n session[:player_id] = @player.id\n session[:new_player] = true\n if session[:creator]\n @player.game.update(creator: @player.id)\n end\n format.turbo_stream\n format.html { redirect_to @player.game, notice: \"Player was successfully created.\" }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n # Find player or create a new one if this one does not exist...\n if params[:player][\"name\"]==\"\" || params[:player][\"email\"]==\"\"\n # Set the player to a generic default, so user can still play\n # without registering\n @player = Player.find_or_create_by_name_and_email(\n {name: \"Dr. Strangelove\",\n email: \"[email protected]\" }) \n else\n # or create/find a player matching the input data\n @player = Player.find_or_create_by_name_and_email(params[:player]) \n end\n\n session[:player_id] = @player.id\n\n respond_to do |format|\n format.js { } # create.js.erb\n end\n end",
"def create\n @player = Player.new(player_params)\n\n if @player.save\n render json: @player, status: :created, location: @player\n else\n render json: {errors: @player.errors}, status: :unprocessable_entity\n end\n end",
"def new\n @game_player = GamePlayer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @game_player }\n end\n end",
"def create\n @all_player = AllPlayer.new(params[:all_player])\n\n respond_to do |format|\n if @all_player.save\n format.html { redirect_to @all_player, notice: 'All player was successfully created.' }\n format.json { render json: @all_player, status: :created, location: @all_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @all_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @leagueplayer = Leagueplayer.new(params[:leagueplayer])\n \n respond_to do |format|\n if @leagueplayer.save\n format.html { redirect_to(@leagueplayer, :notice => 'Leagueplayer was successfully created.') }\n format.xml { render :xml => @leagueplayer, :status => :created, :location => @leagueplayer }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @leagueplayer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @games_player = GamesPlayer.new(params[:games_player])\n\n respond_to do |format|\n if @games_player.save\n format.html { redirect_to(@games_player, :notice => 'Games player was successfully created.') }\n format.xml { render :xml => @games_player, :status => :created, :location => @games_player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @games_player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n player = Player.create(player_params)\n render json: player, status: 201\n end",
"def create\n @player_record = PlayerRecord.new(params[:player_record])\n\n respond_to do |format|\n if @player_record.save\n format.html { redirect_to @player_record, notice: 'Player record was successfully created.' }\n format.json { render json: @player_record, status: :created, location: @player_record }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player_record = PlayerRecord.new(player_record_params)\n\n respond_to do |format|\n if @player_record.save\n format.html { redirect_to @player_record, notice: 'Player record was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player_record }\n else\n format.html { render action: 'new' }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n @players = Player.all\n @players.each do |p|\n if p.id != @player.id\n @team = Team.create(name: p.name[0, 3] + @player.name[0, 3] + (p.id + @player.id).to_s, player_ids: [p.id, @player.id])\n else\n end\n end\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @player_client = PlayerClient.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player_client }\n end\n end",
"def create\n\t\tPlayer.create(player_params.merge(team_id: params[:team_id]))\n\n\t\tredirect_to \"/\"\n\tend",
"def new\n\t\t@game = Game.find(params[:game_id])\n\t\t@player = Player.new\n\n\t\trespond_to do |format|\n\t\t\tformat.html # new.html.erb\n\t\t\tformat.xml { render :xml => @player }\n\t\tend\n\tend",
"def new\n @team = Team.find(params[:team_id])\n @player = @team.players.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @player }\n end\n end",
"def show\n @player = Player.new\n end",
"def create\n player = Player.new(player_params)\n if player.save\n render json: player, status: 201, location: [:api, player]\n else\n failed_to_create(player, \"player\")\n end\n end",
"def create\n @game_player = GamePlayer.new(game_player_params)\n\n respond_to do |format|\n if @game_player.save\n format.html { redirect_to @game_player, notice: \"Game player was successfully created.\" }\n format.json { render :show, status: :created, location: @game_player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @leagueplayer = Leagueplayer.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @leagueplayer }\n end\n end",
"def create\r\n @gameplayer = Gameplayer.new(gameplayer_params)\r\n\r\n respond_to do |format|\r\n if @gameplayer.save\r\n format.html { redirect_to @gameplayer, notice: \"Gameplayer was successfully created.\" }\r\n format.json { render :show, status: :created, location: @gameplayer }\r\n else\r\n format.html { render :new, status: :unprocessable_entity }\r\n format.json { render json: @gameplayer.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create_player\n\t\tputs \"What is your name?\"\n\t\t@player = gets.strip.to_s\n\t\tputs \"Welcome #{@player}!\"\n\tend",
"def create\n @attribute_player = AttributePlayer.new(attribute_player_params)\n\n respond_to do |format|\n if @attribute_player.save\n format.html { redirect_to @attribute_player, notice: 'Attribute player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @attribute_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @attribute_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.game = @game\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to game_player_path(id: @player.id), notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n tournament = Tournament.open.last\n\n if tournament\n @player = tournament.players.new name: params[:name],\n key: SecureRandom.uuid\n if @player.valid?\n @player.save!\n message = { :name => @player.name,\n :key => @player.key,\n :message => @player.key }\n else\n message = { :message => \"You must register with a valid and unique player name.\" }\n end\n\n respond_to do |format|\n format.json { render :json => message }\n format.xml { render :xml => message }\n format.html { redirect_to '/pages/registration', :notice => message[:message] }\n end\n else\n respond_to do |format|\n format.json { render_not_found \"The tournament is currently closed.\" }\n format.xml { render_not_found \"The tournament is currently closed.\" }\n format.html { redirect_to '/pages/registration', :alert => \"The tournament is currently closed.\" }\n end\n end\n end",
"def new\n populate_players\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @game }\n end\n end"
] | [
"0.7257123",
"0.7161786",
"0.71383244",
"0.7124603",
"0.7094017",
"0.7094017",
"0.7094017",
"0.7094017",
"0.7088989",
"0.7088296",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70821893",
"0.70761484",
"0.7068765",
"0.7068765",
"0.7068765",
"0.7068765",
"0.7066134",
"0.7065726",
"0.7065726",
"0.7065726",
"0.7065726",
"0.7065726",
"0.7065726",
"0.7061894",
"0.7057155",
"0.70290786",
"0.6978378",
"0.69730127",
"0.6971606",
"0.6964351",
"0.69448733",
"0.69448733",
"0.69448733",
"0.69448733",
"0.69448733",
"0.6941355",
"0.6895099",
"0.6868426",
"0.6868426",
"0.6857564",
"0.6839045",
"0.6800708",
"0.6793829",
"0.67884684",
"0.67784315",
"0.67715776",
"0.6736334",
"0.67060494",
"0.6700514",
"0.6695207",
"0.6691117",
"0.66881156",
"0.6687127",
"0.6672615",
"0.6659285",
"0.66540897",
"0.66471744",
"0.6644951",
"0.6618205",
"0.65734494",
"0.6567394",
"0.6562194",
"0.65554875",
"0.6547532",
"0.6536496",
"0.65237933",
"0.65227705",
"0.6519507",
"0.65029585",
"0.6502314",
"0.65006167",
"0.64982843",
"0.64842397",
"0.6478048",
"0.6466968",
"0.6463831",
"0.6457727",
"0.6452643",
"0.64501756",
"0.644092",
"0.64244926",
"0.64136636",
"0.6408998",
"0.64075196",
"0.63973176",
"0.6389553",
"0.63738406",
"0.63638365",
"0.6309706",
"0.6289579",
"0.62850124"
] | 0.7629703 | 0 |
Shows form to edit the _Player_. ==== Required params _id_:: id of _Player_ to be edited. ==== Format HTML | def edit
@player = Player.find(params[:id])
respond_to do |format|
format.html {
@buttons = [
{ :body => I18n.t("messages.players.form.back_to_detail"), :url => @player , :html_options => {} },
{ :body => I18n.t("messages.players.form.back_to_list"), :url => players_path, :html_options => {} }
]
}
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edit\n @player = Player.find(params[:id])\n end",
"def edit\n # @player = Player.find(params[:id])\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to [:admin, @player], notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Dane zawodnika zostały uaktualnione.'\n format.html { redirect_to player_path(@player) }\n else\n format.html { render :action => \"edit\" }\n end\n end\n end",
"def edit\n @player_challenge = PlayerChallenge.find(params[:id])\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Zmieniono dane zawodnika.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n# ToDo 0 => Wenn Spieler aktualisiert wurde, schließe das Fenster und aktualisiere die Spielerliste bzw. die Spielerübersicht\n format.html { redirect_to home_path, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @player.update_attributes(player_params)\n flash[:notice] = 'Player was successfully updated.'\n respond_with @player\n else\n render action: 'edit'\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.js\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n\t\t@player = Player.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tif @player.update_attributes(params[:player])\n\t\t\t\tflash[:notice] = 'Player was successfully updated.'\n\t\t\t\tformat.html { redirect_to(@game) }\n\t\t\t\tformat.xml { head :ok }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"edit\" }\n\t\t\t\tformat.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n event \"update\", :player, @player.id, description: \"#{current_player.name} updated the information for #{@player.name}\"\n format.html { redirect_to @player, flash: { success: 'Player was successfully updated.' } }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit(id)\n @user = flash[:form_data] || User[id]\n\n if @user.nil?\n flash[:error] = 'The specified user is invalid'\n redirect_referrer\n end\n\n @title = \"Edit #{@user.username}\"\n\n render_view(:form)\n end",
"def edit \n\t\t#will have template\n\t\t@champion = Champion.find(params[:id])\n\tend",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html {\n redirect_to @player, notice: I18n.t(\"messages.players.update.success\")\n }\n else\n format.html {\n @errors = @league.errors\n render action: \"edit\"\n }\n end\n end\n end",
"def edit\n authorize @competition, :update?\n\n @form = form Competition::Update\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @playerdiv = Playerdiv.find(params[:id])\n\n respond_to do |format|\n if @playerdiv.update_attributes(params[:playerdiv])\n format.html { redirect_to @playerdiv, :notice => 'Playerdiv was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @playerdiv.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n auth!\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to [hardware, @player], :notice => 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def edit\n @playlist = Playlist.find(params['id'])\n end",
"def update\n @player_record = PlayerRecord.find(params[:id])\n respond_to do |format|\n if @player_record.update_attributes(params[:player_record])\n format.html { redirect_to @player_record, notice: 'Player record was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n # Renders the edit form\n end",
"def edit\n @playlist = Playlist.find(params[:id])\n end",
"def edit\n\t\t@song = Song.find(params[:id])\n\tend",
"def edit(id)\n @post = flash[:form_data] || Post[id]\n\n # Make sure the post is valid\n if @post.nil?\n flash[:error] = 'The specified post is invalid'\n redirect_referrer\n end\n\n @title = \"Edit #{@post.title}\"\n\n render_view(:form)\n end",
"def edit\n @song = Song.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to game_player_path(id: @player.id), notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_player.update(team_player_params)\n format.html { redirect_to @team_player, notice: 'Team player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @team_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @client_player = ClientPlayer.find(params[:id])\n\n respond_to do |format|\n if @client_player.update_attributes(params[:client_player])\n format.html { redirect_to @client_player, notice: 'Client player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @client_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @drafted_player.update(drafted_player_params)\n format.html { redirect_to @drafted_player, notice: 'Drafted player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @drafted_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n @player.password_confirmation = @player.password\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to player_url(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors.to_xml }\n end\n end\n end",
"def edit\n @opponent = Opponent.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: \"Player was successfully updated.\" }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: \"Player was successfully updated.\" }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @team = Team.find(params[:team_id])\n @player = @team.players.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to([@player.team, @player], :notice => 'Player was successfully updated.') }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def edit\n @game = Game.find(params[:id])\n end",
"def update\n @all_player = AllPlayer.find(params[:id])\n\n respond_to do |format|\n if @all_player.update_attributes(params[:all_player])\n format.html { redirect_to @all_player, notice: 'All player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @all_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player_record.update(player_record_params)\n format.html { redirect_to @player_record, notice: 'Player record was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n params[:player].delete('country')\n params[:player].delete('auth_token')\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Api::Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @game_player = GamePlayer.find(params[:id])\n\n respond_to do |format|\n if @game_player.update_attributes(params[:game_player])\n format.html { redirect_to @game_player, notice: 'Game player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n @player.create_activity :update, owner: current_user\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @leagueplayer = Leagueplayer.find(params[:id])\n \n respond_to do |format|\n if @leagueplayer.update_attributes(params[:leagueplayer])\n format.html { redirect_to(@leagueplayer, :notice => 'Leagueplayer was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @leagueplayer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n \n if @player.save\n render :json => @player, :status => :ok\n else\n render :json => @player.errors, :status => :unprocessable_entity\n end\n end",
"def edit\n # Mostra la form per modificare un evento\n render \"edit\"\n end",
"def show\n @player = Player.find(params[:id])\n end",
"def edit\n id = params[:id]\n @rock = Rock.find(id)\nend",
"def update\n respond_to do |format|\n if @attribute_player.update(attribute_player_params)\n format.html { redirect_to @attribute_player, notice: 'Attribute player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @attribute_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n bingo_session = BingoSession.find(params[:bingo_session_id])\n @player = bingo_session.players.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.xml { head :ok }\n format.json { render :json => @player}\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @playerprofile = Playerprofile.find(params[:id])\n\n respond_to do |format|\n if @playerprofile.update_attributes(params[:playerprofile])\n format.html { redirect_to @playerprofile, notice: 'Playerprofile was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @playerprofile.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @video = Video.find(params['id'])\n end",
"def edit\n\n end",
"def update\n @user= User.find(params[:id])\n\n respond_to do |format|\n if @user.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'User was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @games_player = GamesPlayer.find(params[:id])\n\n respond_to do |format|\n if @games_player.update_attributes(params[:games_player])\n format.html { redirect_to(@games_player, :notice => 'Games player was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @games_player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def edit\n \t@admingame = Game.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @group_player.update(group_player_params)\n format.html { redirect_to @group_player, notice: 'Group player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @group_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n # return an HTML form for editing a specific user\n @user = User.find(params[:id])\n end",
"def edit(id)\n @lwidth = '20%'\n @rwidth = '0'\n @account = flash[:form_data] || Account[id]\n @tasks = Task.filter(:account_id => id)\n @opports = Opport.filter(:account_id => id)\n session[:method] = 'edit'\n\n # Make sure the item exists\n if @account.nil?\n flash[:error] = 'The specified Account is invalid'\n redirect_referrer\n end\n @name = \"Edit #{@account.name}\"\n Action.add_record(@account.id, session[:email], 'updated', 'account', @account.name)\n @items = Action.recent_items\n end",
"def update\n @player_client = PlayerClient.find(params[:id])\n\n respond_to do |format|\n if @player_client.update_attributes(params[:player_client])\n format.html { redirect_to @player_client, notice: 'Player client was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_client.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n flash[:notice] = 'Se actualizó el Player.' if @player.update_attributes(params[:player])\n respond_with(@player)\n end",
"def update\n @player_message = PlayerMessage.find(params[:id])\n\n respond_to do |format|\n if @player_message.update_attributes(params[:player_message])\n format.html { redirect_to([:scaffold, @player_message], :notice => 'Player message was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player_message.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def edit\n @member = TeamMember.find(params[:id])\n end",
"def show\n @player = Player.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def edit\n @record = Record.find(params[:id])\n end",
"def edit\n\t\t@team = Team.find(params[:id])\n\tend",
"def show\n @player = Player.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def update\n respond_to do |format|\n if @teams_player.update(teams_player_params)\n format.html { redirect_to @teams_player, notice: 'Teams player was successfully updated.' }\n format.json { render :show, status: :ok, location: @teams_player }\n else\n format.html { render :edit }\n format.json { render json: @teams_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @timeline = Timeline.find(params[:id])\n setup_vars_for_edit(@timeline)\n render :template => \"timelines/edit\", :formats => [:html], :handlers => :haml\n end",
"def edit_form\n\t\toptions = { :disabled => false, :show_all => true, :edit => true}\n\t\tform_template(options)\n\tend",
"def edit_form\n\t\toptions = { :disabled => false, :show_all => true, :edit => true}\n\t\tform_template(options)\n\tend",
"def edit\n \n end",
"def edit\n @level = Level.find(params[:id])\n end",
"def edit\n @current_event = Event.find(params[:id])\n # render html: 'edit!'\n end",
"def update\n @player_game = PlayerGame.find(params[:id])\n\n respond_to do |format|\n if @player_game.update_attributes(params[:player_game])\n format.html { redirect_to @player_game, :notice => 'Player game was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player_game.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @playing = Playing.find(params[:id])\n unless current_user.can_modify?(@playing)\n respond_to do |format|\n format.html { redirect_to @playing, status: :forbidden, alert: 'Not allowed' }\n format.json { render json: { error: 'Not allowed' }, status: :forbidden }\n end\n else\n respond_to do |format|\n if @playing.update_attributes(playing_params)\n format.html { redirect_to @playing, notice: 'Playing was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @playing.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def update\n @play = Play.find(params[:id])\n\n respond_to do |format|\n if @play.update_attributes(params[:play])\n format.html { redirect_to @play, notice: 'Play was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @play.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n \t\t@leader = Leader.find(params[:id])\n \tend",
"def edit\n @planet = Planet.find( params[:id] )\n end"
] | [
"0.8022309",
"0.79251647",
"0.72188413",
"0.7170389",
"0.7027778",
"0.6979421",
"0.6979421",
"0.6979421",
"0.6979421",
"0.6979421",
"0.6979421",
"0.69792104",
"0.6964781",
"0.6916975",
"0.686116",
"0.686116",
"0.6844647",
"0.68252224",
"0.67955005",
"0.677978",
"0.6774313",
"0.67621803",
"0.67621803",
"0.67621803",
"0.67621803",
"0.66581815",
"0.6648111",
"0.66210043",
"0.6615143",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.65932006",
"0.6592816",
"0.6587335",
"0.65639323",
"0.65572184",
"0.655072",
"0.6532464",
"0.64764196",
"0.64457154",
"0.6433576",
"0.6425249",
"0.6423916",
"0.6421575",
"0.6417295",
"0.6417058",
"0.64100605",
"0.6405348",
"0.6401486",
"0.63961035",
"0.63790375",
"0.63790375",
"0.6378063",
"0.63649553",
"0.6339779",
"0.633712",
"0.63304424",
"0.63265395",
"0.6269097",
"0.626629",
"0.62432885",
"0.6224888",
"0.621388",
"0.6191991",
"0.61895406",
"0.6181137",
"0.61624867",
"0.6130532",
"0.6130016",
"0.61259574",
"0.6102335",
"0.6082781",
"0.606513",
"0.6062043",
"0.60513765",
"0.60442644",
"0.60440385",
"0.60116553",
"0.60103965",
"0.60003495",
"0.59976095",
"0.5994802",
"0.5986475",
"0.5983534",
"0.59824735",
"0.59817713",
"0.59817713",
"0.5979916",
"0.59754616",
"0.5973784",
"0.59708387",
"0.5969495",
"0.59547156",
"0.5954587",
"0.5954122"
] | 0.7179732 | 3 |
Creates new _Player_ based of params, sent from "new form". ==== Required params _player_:: contains all attributes of _Player_ which should be created. ==== Format HTML | def create
@player = Player.new(params[:player])
respond_to do |format|
if @player.save
format.html {
redirect_to @player, notice: I18n.t("messages.players.create.success")
}
else
format.html {
@errors = @player.errors
render action: "new"
}
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.save\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to [:admin, @player], notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to \"/players/new\", notice: (@player.name + ' was successfully created.') }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: \"Player was successfully created.\" }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to(@player, :notice => 'Player was successfully created.') }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n event \"create\", :player, @player.id, description: \"#{current_player.name} created player #{@player.name}\"\n format.html { redirect_to @player, flash: { success: 'Player was successfully created.' } }\n format.json { render json: @player.to_json(only: public_attrs), status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n puts(params);\n @player = Player.new(player_params)\n \n respond_to do |format|\n if @player.save\n # Tell the playerMailer to send a welcome email after save\n # @user_player = Userplayer.new(user_id: @user.id, player_id: @player_id)\n # if @user_player.save\n @tournament.players << @player\n # @tournament.update_attribute(num_players: @tournament.num_players + 1)\n format.html { redirect_to(root_path, notice: 'player was successfully added.') }\n format.json { render json: @player, status: :created, location: @player }\n # end\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to root_path, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Dodano nowego zawodnika.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n respond_with @player\n else\n render action: :new\n end\n end",
"def create\n @player = Player.new(params[:player])\n @player.user_id = current_user.id\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Player was successfully created.'\n format.html { redirect_to @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.user = current_user\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n format.json { render json: @player, status: :created }\n else\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n player = Player.new(player_params)\n if player.save\n render json: player, status: 201, location: [:api, player]\n else\n failed_to_create(player, \"player\")\n end\n end",
"def create\n @player = Player.new(params[:player])\n \n if @player.save\n render :json => @player, :status => :created, :location => @player\n else\n render :json => @player.errors, :status => :unprocessable_entity\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n flash[:notice] = 'Api::Player was successfully created.'\n format.html { redirect_to(@player) }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.user = current_user\n # automatically create a new team for the user if there isn't one already\n unless @player.team || @player.name.blank?\n team = Team.find_or_initialize_by(name: \"#{@player.name}'s Team\", code: @player.name.upcase)\n @player.team = team if team.save\n end\n respond_to do |format|\n if @player.save\n format.html { redirect_to(@player, :notice => 'Player was successfully created.') }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n else\n team.destroy if team\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n flash[:notice] = 'Se guardó el nuevo Player.' if @player.save\n respond_with(@player)\n end",
"def create\n @player = Player.new(player_params)\n\n if @player.save\n render json: @player, status: :created, location: @player\n else\n render json: {errors: @player.errors}, status: :unprocessable_entity\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n# ToDo 0 => Wenn Spieler erstellt wurde, schließe das Fenster und aktualisiere die Spielerliste bzw. die Spielerübersicht\n format.html { redirect_to home_path, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n respond_to do |format|\n if @player.save\n EventMailer.new_player(@player).deliver\n format.html { redirect_to page_thank_you_path }\n format.json { render action: 'show', status: :created, location: @player }\n else\n format.html { render action: 'new' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n flash[:notice] = \"Player was created successfully.\" if @player.save\n respond_with @player\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n @players = Player.all\n @players.each do |p|\n if p.id != @player.id\n @team = Team.create(name: p.name[0, 3] + @player.name[0, 3] + (p.id + @player.id).to_s, player_ids: [p.id, @player.id])\n else\n end\n end\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n\n respond_to do |format|\n if @player.save\n session[:player_id] = @player.id\n session[:new_player] = true\n if session[:creator]\n @player.game.update(creator: @player.id)\n end\n format.turbo_stream\n format.html { redirect_to @player.game, notice: \"Player was successfully created.\" }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n session[:current_player] = @player\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new(player_params)\n @player.game = @game\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to game_player_path(id: @player.id), notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n player = Player.create(player_params)\n render json: player, status: 201\n end",
"def create\n @player = Player.new(params[:player])\n\n respond_to do |format|\n if @player.save\n @player.create_activity :create, owner: current_user\n format.html { redirect_to @player, notice: 'Player was successfully created.' }\n format.json { render json: @player, status: :created, location: @player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @client_player = ClientPlayer.new(params[:client_player])\n\n respond_to do |format|\n if @client_player.save\n format.html { redirect_to @client_player, notice: 'Client player was successfully created.' }\n format.json { render json: @client_player, status: :created, location: @client_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @client_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @team_player = TeamPlayer.new(team_player_params)\n\n respond_to do |format|\n if @team_player.save\n format.html { redirect_to @team_player, notice: 'Team player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @team_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @team_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @game_player = GamePlayer.new(game_player_params)\n\n respond_to do |format|\n if @game_player.save\n format.html { redirect_to @game_player, notice: \"Game player was successfully created.\" }\n format.json { render :show, status: :created, location: @game_player }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @attribute_player = AttributePlayer.new(attribute_player_params)\n\n respond_to do |format|\n if @attribute_player.save\n format.html { redirect_to @attribute_player, notice: 'Attribute player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @attribute_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @attribute_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @team = Team.find(params[:team_id])\n @player = @team.players.build(params[:player])\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to([@player.team, @player], :notice => 'Player was successfully created.') }\n format.json { render :json => @player, :status => :created, :location => [@player.team, @player] }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @group_player = GroupPlayer.new(group_player_params)\n\n respond_to do |format|\n if @group_player.save\n format.html { redirect_to @group_player, notice: 'Group player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @group_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @group_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\r\n @gameplayer = Gameplayer.new(gameplayer_params)\r\n\r\n respond_to do |format|\r\n if @gameplayer.save\r\n format.html { redirect_to @gameplayer, notice: \"Gameplayer was successfully created.\" }\r\n format.json { render :show, status: :created, location: @gameplayer }\r\n else\r\n format.html { render :new, status: :unprocessable_entity }\r\n format.json { render json: @gameplayer.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create\n\n \t\t\t@player = Player.new player_params\n\n \t\t\tif @player.save\n\n \t\t\t\trender json: @player,status: :created\n\n \t\t\telse\n\n \t\t\t\trender json: {error: true,errors: @player.errors},status: :unprocessable_entity\n\n \t\t\tend\n\n \t\tend",
"def create\n @player_creator = PlayerCreator.new_in_model(@game, player_params, current_user)\n\n respond_to do |format|\n if @player_creator.save\n format.html { redirect_to @game, notice: 'Player successfully joined the Game.' }\n format.json { render :show, status: :created, location: @game }\n else\n format.html { render :new }\n format.json { render json: @game.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player = Player.new\n @player.playername = params[:playername]\n @player.password = params[:password]\n\n if @player.save\n redirect_to \"/login\"\n else\n render :new\n end\n end",
"def create\n @leagueplayer = Leagueplayer.new(params[:leagueplayer])\n \n respond_to do |format|\n if @leagueplayer.save\n format.html { redirect_to(@leagueplayer, :notice => 'Leagueplayer was successfully created.') }\n format.xml { render :xml => @leagueplayer, :status => :created, :location => @leagueplayer }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @leagueplayer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n\t\t@game = Game.find(params[:game_id])\n\t\t@player = Player.new(params[:player])\n\t\[email protected] = @game # required for @player to pass validation\n\t\t\n\t\tif @player.valid? and @game.joinable?\n\t\t\tobserving_game_events(@game) do\n\t\t\t\[email protected]_player(@player)\n\t\t\tend\n\t\t\tannounce_event(\"%s has joined the game\", @player.name)\n\n\t\t\tbecome_player(@player)\n\t\t\t\n\t\t\tif request.xhr?\n\t\t\t\trender :text => \"becomePlayer(#{@player.id})\"\n\t\t\t\treturn\n\t\t\tend\n\n\t\t\trespond_to do |format|\n\t\t\t\tformat.html { redirect_to(@game) }\n\t\t\t\tformat.xml { render :xml => @player, :status => :created, :location => @player }\n\t\t\tend\n\t\telse\n\t\t\tflash[:errors] = 'This game is not available for joining' if [email protected]?\n\t\t\trespond_to do |format|\n\t\t\t\tformat.html { render :action => \"new\" }\n\t\t\t\tformat.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def create\n @teams_player = TeamsPlayer.new(teams_player_params)\n\n respond_to do |format|\n if @teams_player.save\n format.html { redirect_to @teams_player, notice: 'Teams player was successfully created.' }\n format.json { render :show, status: :created, location: @teams_player }\n else\n format.html { render :new }\n format.json { render json: @teams_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t\tPlayer.create(player_params.merge(team_id: params[:team_id]))\n\n\t\tredirect_to \"/\"\n\tend",
"def create\n # Find player or create a new one if this one does not exist...\n if params[:player][\"name\"]==\"\" || params[:player][\"email\"]==\"\"\n # Set the player to a generic default, so user can still play\n # without registering\n @player = Player.find_or_create_by_name_and_email(\n {name: \"Dr. Strangelove\",\n email: \"[email protected]\" }) \n else\n # or create/find a player matching the input data\n @player = Player.find_or_create_by_name_and_email(params[:player]) \n end\n\n session[:player_id] = @player.id\n\n respond_to do |format|\n format.js { } # create.js.erb\n end\n end",
"def create\n plan_id = params[:player].delete(:plan_id)\n travel_date_year = params[:player].delete(:travel_date_year)\n travel_date_season = params[:player].delete(:travel_date_season)\n @player = Player.new(player_params)\n @player.plan = Plan.find(plan_id)\n @player.travel_date = \"#{travel_date_season}/#{travel_date_year}\"\n @player.password = params[:player][:email]\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to active_players_path, notice: 'Player was successfully created.' }\n format.json { render :show, status: :created, location: @player }\n else\n format.html { render :new }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @games_player = GamesPlayer.new(params[:games_player])\n\n respond_to do |format|\n if @games_player.save\n format.html { redirect_to(@games_player, :notice => 'Games player was successfully created.') }\n format.xml { render :xml => @games_player, :status => :created, :location => @games_player }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @games_player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n end",
"def new\n @player = Player.new\n end",
"def new\n\t\t@player = Player.new\n\tend",
"def create\n @player = Player.create!(player_params) # anticipated possible exceptions rescued in BaseController\n render json: @player, status: :created\n end",
"def create\n @fantasy_team_player = FantasyTeamPlayer.create(team_id: @team.id, player_id: params[:player_id])\n unless @fantasy_team_player.new_record?\n render json: @fantasy_team_player, status: :ok, include: [:player]\n else\n render json: error_messages_on_create, status: :unprocessable_entity\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def create\n\t\tavatar = Avatar.new(params[:avatar])\n\t\tavatar_saved = avatar.save\n @player = Player.new(params[:player])\n\t\[email protected] = current_user\n\t\tif avatar_saved\n\t\t\[email protected] = avatar\n\t\tend\n\t\tsaved = @player.save\n\t\tflash[:notice] = 'Zawodnik został dodany' if saved\n\t\tcontinue = !params[:continue].nil?\n\t\trespond_to do |format|\n\t\t\tformat.html do\n\t\t\t\tif saved and continue\n\t\t\t\t\tredirect_to new_player_path\n\t\t\t\telsif saved\n \t redirect_to player_path(@player)\n \telse\n \t render :action => \"new\"\n \tend\n\t\t\tend\n end\n end",
"def create\n @playerdiv = Playerdiv.new(params[:playerdiv])\n\n respond_to do |format|\n if @playerdiv.save\n format.html { redirect_to @playerdiv, :notice => 'Playerdiv was successfully created.' }\n format.json { render :json => @playerdiv, :status => :created, :location => @playerdiv }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @playerdiv.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @drafted_player = DraftedPlayer.new(drafted_player_params)\n\n respond_to do |format|\n if @drafted_player.save\n format.html { redirect_to @drafted_player, notice: 'Drafted player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @drafted_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @drafted_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player_record = PlayerRecord.new(player_record_params)\n\n respond_to do |format|\n if @player_record.save\n format.html { redirect_to @player_record, notice: 'Player record was successfully created.' }\n format.json { render action: 'show', status: :created, location: @player_record }\n else\n format.html { render action: 'new' }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n\t\t# @team = Team.find(params[:team_id]) --see above for assign_team\n\n\t\t# by writing this ..we can connect it in the new form new.html.erb\n\t\t@player = Player.new\n\tend",
"def create\n puts params\n game = CreateGame.new(\n max_rounds: params[:max_rounds],\n draw_time: params[:draw_time],\n ).perform\n player = CreatePlayer.new(\n username: params[:username],\n game: game,\n creator: true\n ).perform\n\n if game.persisted? && player.persisted?\n session[:uuid] = player.uuid\n redirect_to player_path\n else\n render json: { ok: 'gra nie zapisana :(' }\n end\n end",
"def player_attributes=(player_params)\n if !player_params['name'].empty?\n self.player = Player.find_or_create_by(player_params)\n end\n end",
"def create\n player_params = {\"name\"=>room_params[:leader], score: 0, lives: 2}\n \n @room = Room.new(room_params)\n @room.round = 0\n\n respond_to do |format|\n if @room.save\n @player = @room.players.create(player_params)\n if @player.save\n session[:player_id] = @player.id\n format.html { redirect_to @room, notice: 'Room and Player were successfully created.' }\n format.json { render :show, status: :created, location: @room }\n else\n format.html { render :new }\n format.json { render json: @room.errors, status: :unprocessable_entity }\n end\n else\n format.html { render :new }\n format.json { render json: @room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @player_record = PlayerRecord.new(params[:player_record])\n\n respond_to do |format|\n if @player_record.save\n format.html { redirect_to @player_record, notice: 'Player record was successfully created.' }\n format.json { render json: @player_record, status: :created, location: @player_record }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n \t#Add player to playground\n @playground = current_playground\n @playgrounds = Playground.all\n #Reset player question variables\n\t@player = Player.find(params[:player_id])\n\[email protected]_attribute(:number_response, 0)\n\[email protected]_attribute(:correct, -1)\n\[email protected]_attribute(:time, 1000)\n\[email protected]_attribute(:winner, -1)\n\t\n\t@game_player = @playground.game_players.build(player: @player)\n\t\n respond_to do |format|\n if @game_player.save\n format.html { redirect_to board_url }\n format.js\n format.json { render json: @game_player, status: :created, location: @game_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n user = Player.create!(player_params)\n session[:user_id] = user.id\n \n if user.valid?\n render json: player, status: :created\n else\n render json: { errors: user.errors.full_messages }, status: :unprocessable_entity\n end\n end",
"def create\n @all_player = AllPlayer.new(params[:all_player])\n\n respond_to do |format|\n if @all_player.save\n format.html { redirect_to @all_player, notice: 'All player was successfully created.' }\n format.json { render json: @all_player, status: :created, location: @all_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @all_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n end",
"def create\n tournament = Tournament.open.last\n\n if tournament\n @player = tournament.players.new name: params[:name],\n key: SecureRandom.uuid\n if @player.valid?\n @player.save!\n message = { :name => @player.name,\n :key => @player.key,\n :message => @player.key }\n else\n message = { :message => \"You must register with a valid and unique player name.\" }\n end\n\n respond_to do |format|\n format.json { render :json => message }\n format.xml { render :xml => message }\n format.html { redirect_to '/pages/registration', :notice => message[:message] }\n end\n else\n respond_to do |format|\n format.json { render_not_found \"The tournament is currently closed.\" }\n format.xml { render_not_found \"The tournament is currently closed.\" }\n format.html { redirect_to '/pages/registration', :alert => \"The tournament is currently closed.\" }\n end\n end\n end",
"def createPlayer(params)\n \n # Create a hash\n doc = {:type => \"Person\"}\n \n # Set the name\n doc[:name] = params[\"name\"]\n \n # Set the email\n doc[:email] = params[\"email\"]\n \n # Set the username\n doc[:username] = params[\"username\"]\n \n # Set the guest flag\n doc[:guest] = params[\"guest\"] ? true : false\n \n # Set the current date\n doc[:date] = Time.now.to_i\n \n # Get a new id from the CouchDB server\n uuid = CouchDB.nextUUID @server\n doc[:_id] = uuid\n \n # Put it to the database\n response = CouchRest.put @server + \"/#{CouchDB::DB}/#{uuid}\", doc\n \n return response != false\n \n end",
"def create_player(name)\n {\n \"id\" => @player_class.create(:player_name => name).id\n }\n end",
"def create\n bingo_session = BingoSession.find(params[:bingo_session_id])\n @player = Player.new(params[:player])\n @player.bingo_session = bingo_session\n @player.caller = current_caller\n\n respond_to do |format|\n if @player.save\n format.html { redirect_to(@player, :notice => 'Player was successfully created.') }\n format.xml { render :xml => @player, :status => :created, :location => @player }\n format.json { render :json => @player}\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n json = ActiveSupport::JSON.decode(params[:player])\n @player = Player.new\n @player.gender = json[\"gender\"]\n @player.username = json[\"username\"]\n @player.uuid = json[\"uuid\"]\n @player.last_location = json[\"location\"]\n @player.player_monsters = [ PlayerMonster.new({ :nickname => json[\"starting_monster\"][\"nickname\"],\n :monster_id => json[\"starting_monster\"][\"id\"],\n :caught_location => json[\"location\"]\n }) ]\n if @player.save\n render :json => { :success => true, :player => @player } , :status => 200\n else\n render :json => { :success => false, :message => @player.errors } , :status => 400\n end\n end",
"def create\n @game_session_player = GameSessionPlayer.new(game_session_player_params)\n\n respond_to do |format|\n if @game_session_player.save\n format.html { redirect_to @game_session_player, notice: 'Game session player was successfully created.' }\n format.json { render :show, status: :created, location: @game_session_player }\n else\n format.html { render :new }\n format.json { render json: @game_session_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player }\n end\n end",
"def create\n @unavailable_player = UnavailablePlayer.new(unavailable_player_params)\n\n respond_to do |format|\n if @unavailable_player.save\n format.html { redirect_to @unavailable_player, notice: 'Unavailable player was successfully created.' }\n format.json { render action: 'show', status: :created, location: @unavailable_player }\n else\n format.html { render action: 'new' }\n format.json { render json: @unavailable_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @player = Player.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @player.to_json(only: public_attrs) }\n end\n end",
"def create\n @play = Play.new(play_params)\n @play.player = current_player\n respond_to do |format|\n if @play.save\n format.html { redirect_to @play, notice: 'Play was successfully created.' }\n format.json { render :show, status: :created, location: @play }\n else\n format.html { render :new }\n format.json { render json: @play.errors, status: :unprocessable_entity }\n end\n end\n end",
"def generate_player\n ret_val = nil\n msg = \"no changes made\"\n if (!ranking_player.nil?) and !has_base_player\n ret_val = PlayersHelper.generate_player_from_url(ranking_player)\n if !ret_val.nil?\n self.player = ret_val\n if base_player_country_id != base_country_id \\\n and !base_player_country.nil?\n self.country = base_player_country\n end\n self.resolved = true\n self.save!\n msg = \"Created new player \" + base_player_name + \"/\" + \\\n base_player_code + \"/id=\" + ret_val.id.to_s\n else\n msg = \"Player creation failed from url: \" + rp_url\n end\n end\n\n SystemLog.log(msg)\n ret_val\n end"
] | [
"0.79812723",
"0.79812723",
"0.79812723",
"0.79812723",
"0.79812723",
"0.79812723",
"0.79694045",
"0.7965806",
"0.79553896",
"0.79508805",
"0.7945333",
"0.7945333",
"0.7945333",
"0.7945333",
"0.79193145",
"0.79193145",
"0.79193145",
"0.79193145",
"0.7910081",
"0.78857356",
"0.78770775",
"0.786833",
"0.78606296",
"0.785646",
"0.7825628",
"0.78055346",
"0.77848375",
"0.7764099",
"0.7720302",
"0.7698967",
"0.76815236",
"0.7672658",
"0.76684004",
"0.7666472",
"0.76143676",
"0.7610697",
"0.7606056",
"0.7600654",
"0.75872517",
"0.75866765",
"0.75808394",
"0.75026983",
"0.74966496",
"0.7478879",
"0.7469407",
"0.7469001",
"0.73832685",
"0.73537296",
"0.7353336",
"0.729911",
"0.7274086",
"0.724673",
"0.7227388",
"0.7221978",
"0.72213745",
"0.7210302",
"0.719902",
"0.71838206",
"0.717291",
"0.71691126",
"0.71590567",
"0.71508926",
"0.71508926",
"0.7136692",
"0.7115853",
"0.71022207",
"0.7093316",
"0.7079716",
"0.7069747",
"0.70619357",
"0.706024",
"0.70540047",
"0.70507824",
"0.70233786",
"0.70224434",
"0.70213366",
"0.70209247",
"0.70177686",
"0.70164126",
"0.70061123",
"0.70038515",
"0.69956714",
"0.69941866",
"0.69828296",
"0.69152486",
"0.69143885",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.6906455",
"0.68924844",
"0.6884232",
"0.68503803",
"0.68354416"
] | 0.7936719 | 14 |
Updates _Player_ based of params, sent from "edit form". ==== Required params _id_:: id of _Player_ to be updated. _player_:: contains all attributes of _Player_ which should be updated. ==== Format HTML | def update
@player = Player.find(params[:id])
respond_to do |format|
if @player.update_attributes(params[:player])
format.html {
redirect_to @player, notice: I18n.t("messages.players.update.success")
}
else
format.html {
@errors = @league.errors
render action: "edit"
}
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to [:admin, @player], notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\t\t@player = Player.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tif @player.update_attributes(params[:player])\n\t\t\t\tflash[:notice] = 'Player was successfully updated.'\n\t\t\t\tformat.html { redirect_to(@game) }\n\t\t\t\tformat.xml { head :ok }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"edit\" }\n\t\t\t\tformat.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def update\n @player = Player.find(params[:id])\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Dane zawodnika zostały uaktualnione.'\n format.html { redirect_to player_path(@player) }\n else\n format.html { render :action => \"edit\" }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n event \"update\", :player, @player.id, description: \"#{current_player.name} updated the information for #{@player.name}\"\n format.html { redirect_to @player, flash: { success: 'Player was successfully updated.' } }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @player.update_attributes(player_params)\n flash[:notice] = 'Player was successfully updated.'\n respond_with @player\n else\n render action: 'edit'\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Zmieniono dane zawodnika.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.js\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to game_player_path(id: @player.id), notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n player = Player.find(params[:id])\n if player.update(player_params)\n render json: player, status: 200, location: [:api, player]\n else\n failed_to_update(player, \"player\")\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n# ToDo 0 => Wenn Spieler aktualisiert wurde, schließe das Fenster und aktualisiere die Spielerliste bzw. die Spielerübersicht\n format.html { redirect_to home_path, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: \"Player was successfully updated.\" }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.html { redirect_to @player, notice: \"Player was successfully updated.\" }\n format.json { render :show, status: :ok, location: @player }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n flash[:notice] = 'Se actualizó el Player.' if @player.update_attributes(params[:player])\n respond_with(@player)\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n @player.create_activity :update, owner: current_user\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n auth!\n\n respond_to do |format|\n if @player.update_attributes(player_params)\n format.html { redirect_to [hardware, @player], :notice => 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n\n respond_to do |format|\n params[:player].delete('country')\n params[:player].delete('auth_token')\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Api::Player was successfully updated.'\n format.html { redirect_to(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player = Player.find(params[:id])\n \n if @player.save\n render :json => @player, :status => :ok\n else\n render :json => @player.errors, :status => :unprocessable_entity\n end\n end",
"def update\n @team = Team.find(params[:team_id])\n @player = @team.players.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to([@player.team, @player], :notice => 'Player was successfully updated.') }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n bingo_session = BingoSession.find(params[:bingo_session_id])\n @player = bingo_session.players.find(params[:id])\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n format.html { redirect_to(@player, :notice => 'Player was successfully updated.') }\n format.xml { head :ok }\n format.json { render :json => @player}\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors, :status => :unprocessable_entity }\n format.json { render :json => @player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n format.json { render json: @player, status: :ok }\n else\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @game_player = GamePlayer.find(params[:id])\n\n respond_to do |format|\n if @game_player.update_attributes(params[:game_player])\n format.html { redirect_to @game_player, notice: 'Game player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @client_player = ClientPlayer.find(params[:id])\n\n respond_to do |format|\n if @client_player.update_attributes(params[:client_player])\n format.html { redirect_to @client_player, notice: 'Client player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @client_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @player.update(player_params)\n render json: @player, status: :ok\n else\n render json: {errors: @player.errors}, status: :unprocessable_entity\n end\n end",
"def update\n @user= User.find(params[:id])\n\n respond_to do |format|\n if @user.update_attributes(params[:player])\n format.html { redirect_to @player, notice: 'User was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n flash[:notice] = \"Player was created successfully.\" if @player.update(player_params)\n respond_with(@player)\n end",
"def update\n @player = Player.find(params[:id])\n @player.password_confirmation = @player.password\n\n respond_to do |format|\n if @player.update_attributes(params[:player])\n flash[:notice] = 'Player was successfully updated.'\n format.html { redirect_to player_url(@player) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @player.errors.to_xml }\n end\n end\n end",
"def update_player\n @player.update\n update_player_actions\n end",
"def update\n @player.update(player_params)\n render json: @player, status: 200\n end",
"def update\n @all_player = AllPlayer.find(params[:id])\n\n respond_to do |format|\n if @all_player.update_attributes(params[:all_player])\n format.html { redirect_to @all_player, notice: 'All player was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @all_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_player.update(team_player_params)\n format.html { redirect_to @team_player, notice: 'Team player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @team_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @attribute_player.update(attribute_player_params)\n format.html { redirect_to @attribute_player, notice: 'Attribute player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @attribute_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @player = Player.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @game_player.update(game_player_params)\n format.html { redirect_to @game_player, notice: \"Game player was successfully updated.\" }\n format.json { render :show, status: :ok, location: @game_player }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @playerdiv = Playerdiv.find(params[:id])\n\n respond_to do |format|\n if @playerdiv.update_attributes(params[:playerdiv])\n format.html { redirect_to @playerdiv, :notice => 'Playerdiv was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @playerdiv.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @leagueplayer = Leagueplayer.find(params[:id])\n \n respond_to do |format|\n if @leagueplayer.update_attributes(params[:leagueplayer])\n format.html { redirect_to(@leagueplayer, :notice => 'Leagueplayer was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @leagueplayer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @games_player = GamesPlayer.find(params[:id])\n\n respond_to do |format|\n if @games_player.update_attributes(params[:games_player])\n format.html { redirect_to(@games_player, :notice => 'Games player was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @games_player.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @player.update!(player_params) # anticipated possible exceptions rescued in BaseController\n render json: @player, status: 200\n end",
"def update\n @player_record = PlayerRecord.find(params[:id])\n respond_to do |format|\n if @player_record.update_attributes(params[:player_record])\n format.html { redirect_to @player_record, notice: 'Player record was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n if @player.update(player_params)\n\n render json: @player,status: :ok\n\n else\n\n render json: {error: true,errors: @player.errors},status: :unprocessable_entity\n\n end\n\n \t\tend",
"def edit\n # @player = Player.find(params[:id])\n end",
"def update\r\n respond_to do |format|\r\n if @gameplayer.update(gameplayer_params)\r\n format.html { redirect_to @gameplayer, notice: \"Gameplayer was successfully updated.\" }\r\n format.json { render :show, status: :ok, location: @gameplayer }\r\n else\r\n format.html { render :edit, status: :unprocessable_entity }\r\n format.json { render json: @gameplayer.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n room_code = params[:player][:room_id]\n room = Room.find_by_code(room_code)\n\n respond_to do |format|\n if @player.update(player_params.merge(room_id: room.id))\n format.html { redirect_to \"/play/#{room.id}/#{@player.id}\", notice: 'Player was successfully updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update\n respond_to do |format|\n if @teams_player.update(teams_player_params)\n format.html { redirect_to @teams_player, notice: 'Teams player was successfully updated.' }\n format.json { render :show, status: :ok, location: @teams_player }\n else\n format.html { render :edit }\n format.json { render json: @teams_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @drafted_player.update(drafted_player_params)\n format.html { redirect_to @drafted_player, notice: 'Drafted player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @drafted_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @group_player.update(group_player_params)\n format.html { redirect_to @group_player, notice: 'Group player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @group_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player.update(player_params)\n # TODO: email the player if there is a team associated\n\t# This email only goes out if the old_value is nil and new_value\n\t# is truthy\n format.html { redirect_to @player, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @game_player.update(game_player_params)\n format.html { redirect_to case_game_round_path(@game_player.game_round), notice: '玩家信息更新成功.' }\n format.json { render :show, status: :ok, location: @game_player }\n else\n format.html { render :edit }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player_action.update(player_action_params)\n format.html { redirect_to @player_action, notice: 'Player action was successfully updated.' }\n format.json { render :show, status: :ok, location: @player_action }\n else\n format.html { render :edit }\n format.json { render json: @player_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player_record.update(player_record_params)\n format.html { redirect_to @player_record, notice: 'Player record was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @player_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player_game = PlayerGame.find(params[:id])\n\n respond_to do |format|\n if @player_game.update_attributes(params[:player_game])\n format.html { redirect_to @player_game, :notice => 'Player game was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @player_game.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @playerprofile = Playerprofile.find(params[:id])\n\n respond_to do |format|\n if @playerprofile.update_attributes(params[:playerprofile])\n format.html { redirect_to @playerprofile, notice: 'Playerprofile was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @playerprofile.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @player_status.update(player_status_params)\n format.html { redirect_to @player_status, notice: 'Player status was successfully updated.' }\n format.json { render :show, status: :ok, location: @player_status }\n else\n format.html { render :edit }\n format.json { render json: @player_status.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @admin_player.update(admin_User_params)\n format.html { redirect_to admin_player_path(@admin_player) , notice: 'Player was successfully updated.' }\n format.json { render :show, status: :ok, location: @admin_User }\n else\n flash[:error] = @admin_player.errors.full_messages\n format.html { render :edit }\n format.json { render json: @admin_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @game_session_player.update(game_session_player_params)\n format.html { redirect_to @game_session_player, notice: 'Game session player was successfully updated.' }\n format.json { render :show, status: :ok, location: @game_session_player }\n else\n format.html { render :edit }\n format.json { render json: @game_session_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @unavailable_player.update(unavailable_player_params)\n format.html { redirect_to @unavailable_player, notice: 'Unavailable player was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @unavailable_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player_client = PlayerClient.find(params[:id])\n\n respond_to do |format|\n if @player_client.update_attributes(params[:player_client])\n format.html { redirect_to @player_client, notice: 'Player client was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_client.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @player_promise = PlayerPromise.find(params[:id])\n\n respond_to do |format|\n if @player_promise.update_attributes(params[:player_promise])\n format.html { redirect_to @player_promise, notice: 'Player promise was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_promise.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_player\n @player = Player.find params[:id]\n end",
"def update\n @user = @player_profile.user\n respond_to do |format|\n\n if @player_profile.update_attributes(player_profile_params)\n\n format.html { redirect_to user_player_profiles_path(@user, @player_profile), notice: 'Player profile was successfully updated.' }\n format.json { render :show, status: :ok, location: @player_profile }\n else\n format.html { render :edit }\n format.json { render json: @player_profile.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end",
"def set_player\n @player = Player.find(params[:id])\n end"
] | [
"0.8323834",
"0.8152856",
"0.81502503",
"0.8148995",
"0.81228137",
"0.8122738",
"0.8122738",
"0.8122738",
"0.8122738",
"0.8122738",
"0.8122738",
"0.8115571",
"0.80991334",
"0.80336255",
"0.80336255",
"0.80027324",
"0.7968097",
"0.7920487",
"0.7893469",
"0.7893469",
"0.7893469",
"0.7893469",
"0.7893469",
"0.7893469",
"0.7893469",
"0.78927064",
"0.7892704",
"0.7883572",
"0.78728855",
"0.78505284",
"0.78505284",
"0.78505284",
"0.78505284",
"0.78008884",
"0.7797844",
"0.7797844",
"0.7742728",
"0.7732983",
"0.7720855",
"0.76997",
"0.76791686",
"0.76576066",
"0.75761694",
"0.7543636",
"0.7530078",
"0.74990404",
"0.7490564",
"0.7488635",
"0.7477998",
"0.7466394",
"0.7460093",
"0.7427499",
"0.73924834",
"0.7382158",
"0.7354417",
"0.7284686",
"0.7232801",
"0.7211056",
"0.7201357",
"0.71929526",
"0.71647614",
"0.71625024",
"0.7154502",
"0.7150242",
"0.71004254",
"0.70633316",
"0.7036247",
"0.7023562",
"0.70104784",
"0.70036954",
"0.6989699",
"0.6981975",
"0.69767773",
"0.6964112",
"0.69119287",
"0.6873112",
"0.68227166",
"0.681332",
"0.67761546",
"0.6769751",
"0.6768901",
"0.67525685",
"0.67372036",
"0.67059636",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675",
"0.66965675"
] | 0.7707456 | 39 |
Deletes _Player_. ==== Required params _id_:: id of _Player_ that should be deleted. ==== Format HTML | def destroy
@player = Player.find(params[:id])
@player.destroy
respond_to do |format|
format.html {
redirect_to players_url
}
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @player = Player.find(params[:id])\n if @player.destroy\n flash[:success] = \"Player was deleted.\"\n else\n flash[:error] = \"Player could not be deleted.\"\n end\n redirect_to players_path\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n player = Player.find(params[:id])\n player.destroy\n head 204\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n event \"delete\", :player, @player.id, description: \"#{current_player.name} deleted player #{@player.name}\"\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n respond_to do |format|\n format.html { redirect_to(players_path) }\n\t\t\tformat.js do\n\t\t\t\trender :update do |page|\n\t\t\t\t\tpage.replace_html \"player-#{@player.id}\", ''\n\t\t\t\tend\n\t\t\tend\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n render :json => \"Ok\", :status => :ok\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(api_players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: t( '.success' ) }\n end\n end",
"def destroy\n\n if @player.destroy\n\n render json: {player: {id: params[:id].to_i}},status: :ok\n\n else\n\n render json: {error: true,errors: @player.errors},status: :unprocessable_entity\n\n end\n\n \t\tend",
"def destroy\n @player.destroy\n\n head :no_content\n end",
"def destroy\n flash[:notice] = 'Se eliminó el Player.' if @player.destroy\n respond_with(@player)\n end",
"def destroy\n @player.destroy\n @destroy_message = \"Success deleted!\"\n render :show\n end",
"def destroy\n @player.destroy\n flash[:notice] = 'Player successfully deleted.'\n respond_with @player\n end",
"def destroy\n @playerdiv = Playerdiv.find(params[:id])\n @playerdiv.destroy\n\n respond_to do |format|\n format.html { redirect_to playerdivs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n auth!\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to hardware.players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @all_player = AllPlayer.find(params[:id])\n @all_player.destroy\n\n respond_to do |format|\n format.html { redirect_to all_players_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to game_players_path, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url, notice: \"Player was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @client_player = ClientPlayer.find(params[:id])\n @client_player.destroy\n\n respond_to do |format|\n format.html { redirect_to client_players_url }\n format.json { head :ok }\n end\n end",
"def destroy\n \n @drafted_player.destroy\n respond_to do |format|\n format.html { redirect_to drafted_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @player.destroy\n head :no_content\n else\n render json: {errors: @player.errors}, status: :unprocessable_entity\n end\n end",
"def destroy\n @game_player = GamePlayer.find(params[:id])\n @game_player.destroy\n\n respond_to do |format|\n format.html { redirect_to game_players_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.html { redirect_to players_url(team_id: @player.team.id) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.create_activity :destroy, owner: current_user\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @admin_player.destroy\n respond_to do |format|\n format.html { redirect_to admin_players_url, notice: 'Player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @games_player = GamesPlayer.find(params[:id])\n @games_player.destroy\n\n respond_to do |format|\n format.html { redirect_to(games_players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n\t\[email protected]\n\t\tredirect_to \"/\"\n\tend",
"def destroy\n bingo_session = BingoSession.find(params[:bingo_session_id])\n @player = bingo_session.players.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n format.json { head :ok }\n end\n end",
"def destroy\n @player_record = PlayerRecord.find(params[:id])\n @player_record.destroy\n\n respond_to do |format|\n format.html { redirect_to player_records_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_with(@player)\n end",
"def destroy\n @team_player.destroy\n respond_to do |format|\n format.html { redirect_to team_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @game_player.destroy\n respond_to do |format|\n format.html { redirect_to game_players_url, notice: \"Game player was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player = Player.find(params[:id])\n @player.password_confirmation = @player.password\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to players_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n format.turbo_stream\n format.html { redirect_to players_url, notice: \"Player was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_client = PlayerClient.find(params[:id])\n @player_client.destroy\n\n respond_to do |format|\n format.html { redirect_to player_clients_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @team = Team.find(params[:team_id])\n @player = @team.players.find(params[:id])\n @player.destroy\n\n respond_to do |format|\n format.html { redirect_to team_players_url(@team) }\n format.json { head :ok }\n end\n end",
"def destroy\n @player_strong.destroy\n respond_to do |format|\n format.html { redirect_to project_strong_players_groups_path, notice: 'Zawodnik usunięty pomyślnie.' }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n @player_game = PlayerGame.find(params[:id])\n @player_game.destroy\n\n respond_to do |format|\n format.html { redirect_to player_games_url }\n format.json { head :no_content }\n end\n end",
"def destroy\r\n @gameplayer.destroy\r\n respond_to do |format|\r\n format.html { redirect_to gameplayers_url, notice: \"Gameplayer was successfully destroyed.\" }\r\n format.json { head :no_content }\r\n end\r\n end",
"def destroy\n @leagueplayer = Leagueplayer.find(params[:id])\n @leagueplayer.destroy\n \n respond_to do |format|\n format.html { redirect_to(leagueplayers_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player.destroy\n render json: @player.as_json.merge(deleted_at: Time.now.utc.iso8601), status: 200\n end",
"def destroy\n @player_statistic = PlayerStatistic.find(params[:id])\n @player_statistic.destroy\n\n respond_to do |format|\n format.html { redirect_to player_statistics_url }\n format.json { head :no_content }\n end\n end",
"def remove_player\n @team.remove_player(@player)\n\n redirect_to team_path(@team)\n end",
"def destroy\n if @fantasy_team_player.destroy\n render json: @fantasy_team_player, status: :ok, include: [:player]\n else\n render json: { message: 'could not delete' }, status: :unprocessable_entity\n end\n end",
"def destroy\n @player_message = PlayerMessage.find(params[:id])\n @player_message.destroy\n\n respond_to do |format|\n format.html { redirect_to(scaffold_player_messages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player.user.destroy\n\n respond_to do |format|\n format.html { redirect_to(players_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @player_record.destroy\n respond_to do |format|\n format.html { redirect_to player_records_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_action.destroy\n respond_to do |format|\n format.html { redirect_to player_actions_url, notice: 'Player action was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @playerprofile = Playerprofile.find(params[:id])\n @playerprofile.destroy\n\n respond_to do |format|\n format.html { redirect_to playerprofiles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_game_stat = PlayerGameStat.find(params[:id])\n @player_game_stat.destroy\n\n respond_to do |format|\n format.html { redirect_to player_game_stats_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @group_player.destroy\n respond_to do |format|\n format.html { redirect_to group_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @video_player = Embeddable::VideoPlayer.find(params[:id])\n respond_to do |format|\n format.html { redirect_to(video_players_url) }\n format.xml { head :ok }\n format.js\n end\n\n # TODO: We should move this logic into the model!\n @video_player.page_elements.each do |pe|\n pe.destroy\n end\n @video_player.destroy\n end",
"def destroy\n @teams_player.destroy\n respond_to do |format|\n format.html { redirect_to teams_players_url, notice: 'Teams player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @game_session_player.destroy\n respond_to do |format|\n format.html { redirect_to game_session_players_url, notice: 'Game session player was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def remove_player(table_id)\n\t\t\t\tplayer_for(table_id).quit\n\t\t\t\[email protected](table_id)\n\t\t\tend",
"def destroy\n @opponent = Opponent.find(params[:id])\n if @opponent.delete\n flash[:notice] = 'Persona deleted!'\n head :no_content\n else\n flash[:error] = 'Failed to delete this persona!'\n render :destroy\n end\n end",
"def destroy\n @d_play.destroy\n respond_to do |format|\n format.html { redirect_to d_plays_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @unavailable_player.destroy\n respond_to do |format|\n format.html { redirect_to unavailable_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n game = Game.find(params[:game_id])\n @player_game = game.player_games.find(params[:id])\n @player_game.destroy\n\n respond_to do |format|\n format.html { redirect_to(player_games_path, :notice => 'Player game was successfully removed.') }\n format.xml { head :ok }\n format.json { render :json => @player_game}\n end\n end",
"def destroy\n @attribute_player.destroy\n respond_to do |format|\n format.html { redirect_to attribute_players_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player.destroy\n respond_to do |format|\n \n if user_signed_in?\n format.html { redirect_to user_chars_path }#, notice: 'Player was successfully created.' }\n elsif master_signer_in?\n format.html { redirect_to players_url } #, notice: 'Player was successfully created.' }\n end\n \n end\n end",
"def delete\n\t\t\t\"delete called - deleting object #{params[:id]}\"\n\t\tend",
"def destroy\n @player_promise = PlayerPromise.find(params[:id])\n @player_promise.destroy\n\n respond_to do |format|\n format.html { redirect_to player_promises_url }\n format.json { head :ok }\n end\n end",
"def destroy\n team = @player.team\n @player.destroy\n respond_to do |format|\n format.html { redirect_to team }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_challenge = PlayerChallenge.find(params[:id])\n @player_challenge.destroy\n respond_to do |format|\n format.html { redirect_to player_challenges_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @gameplay = Gameplay.find(params[:id])\n @gameplay.destroy\n\n respond_to do |format|\n format.html { redirect_to gameplays_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @default_player_datum = DefaultPlayerDatum.find(params[:id])\n @default_player_datum.destroy\n\n respond_to do |format|\n format.html { redirect_to default_player_data_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @player_status.destroy\n respond_to do |format|\n format.html { redirect_to player_statuses_url, notice: 'Player status was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n id = params[:id].to_i\n UserGame.find(id)\n @user_game.destroy\n respond_to do |format|\n format.html { redirect_to user_games_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_note = PlayerNote.find(params[:id])\n @player_note.destroy\n\n respond_to do |format|\n format.html { redirect_to(scaffold_player_notes_url) }\n format.xml { head :ok }\n end\n end"
] | [
"0.77954197",
"0.7697658",
"0.76735634",
"0.75682646",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7497589",
"0.7478423",
"0.7478423",
"0.7456991",
"0.7401319",
"0.7393691",
"0.738467",
"0.738467",
"0.738467",
"0.738467",
"0.738467",
"0.725504",
"0.72272724",
"0.7218202",
"0.7214526",
"0.7194976",
"0.71666557",
"0.7133616",
"0.711725",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71156627",
"0.71133167",
"0.71117806",
"0.71076155",
"0.7104028",
"0.7104028",
"0.7104028",
"0.70986754",
"0.7077871",
"0.7076989",
"0.70149136",
"0.7007229",
"0.6956175",
"0.6910176",
"0.689929",
"0.6882086",
"0.68766916",
"0.6854361",
"0.6854324",
"0.68473846",
"0.68024224",
"0.67616785",
"0.67343765",
"0.67312884",
"0.67023355",
"0.6663487",
"0.66606367",
"0.6641838",
"0.66379446",
"0.66339403",
"0.6622871",
"0.6622617",
"0.66221935",
"0.66199446",
"0.66113645",
"0.6610452",
"0.65880036",
"0.657904",
"0.6572875",
"0.6537945",
"0.65376395",
"0.6525523",
"0.65086734",
"0.65042144",
"0.6473143",
"0.647253",
"0.6459664",
"0.6448546",
"0.640651",
"0.6404351",
"0.64038026",
"0.63824046",
"0.6367549",
"0.63573563",
"0.63494",
"0.6348257",
"0.6345153",
"0.6340139",
"0.6335389",
"0.63165027",
"0.6307654"
] | 0.75768006 | 3 |
Adds black mark to _Player_. ==== Required params _count_:: number of added dots. _id_:: id of _Player_ to which black mark should be added. _reason_:: number of reason or undefined when reason id should be null. _description_:: additional description of reason (text). ==== Format JSON | def add_black_dot
reason = params[:reason] != nil && params[:reason] != "" ? params[:reason].to_i : nil
count = params[:count] != nil && params[:count] != "" ? params[:count].to_i : 1
desc = params[:description] != nil && params[:description] != "" ? params[:description] : nil
ActiveRecord::Base.transaction do
@dot = BlackDot.new
@dot.count = count
@dot.player_id = params[:id]
@dot.reason = reason
@dot.description = desc
@res1 = @dot.save
@player = Player.find(params[:id])
@player.dots_total = @player.dots_total + count
@res2 = @player.save
end
respond_to do |format|
format.json {
render json: {
:status => @res1 && @res2,
:dot => @dot,
:reason => @dot.reason == nil ? nil : I18n.t("messages.black_dot_reason.reason" + @dot.reason.to_s),
:description => @dot.description
}
}
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bad\n \tunless is_numeric? params[:id]\n \t\t@player = Player.create({ gamertag: params[:id] })\n \telse\n \t\t@player = Player.find(params[:id])\n \tend\n\n \[email protected] = \"bad\"\n \[email protected]\n\n \trespond_to do |format|\n \t\tformat.js\n \tend\n end",
"def good\n \tunless is_numeric? params[:id]\n \t\t@player = Player.create({ gamertag: params[:id] })\n \telse\n \t\t@player = Player.find(params[:id])\n \tend\n\n \[email protected] = \"good\"\n \[email protected]\n\n \trespond_to do |format|\n \t\tformat.js\n \tend\n end",
"def count\n @game = Game.find_by(id: params[:id])\n @game.plays = @game.plays + 1\n @game.save!\n render json: {\n id: @game.id,\n name: @game.name,\n tags: @game.tags,\n user_id: @game.user_id,\n description: @game.description,\n published: @game.published,\n plays: @game.plays\n }\n end",
"def blacklist_song_create\n @check = \"ERROR\"\n \n unless params[:id].nil? || params[:song_id].nil?\n if User.find(params[:id]).blacklist_songs.where(song_id: params[:song_id]).count != 0\n return render json: {status: @check, message: \"이미 차단 설정된 노래입니다\"}\n end\n bs = BlacklistSong.new\n bs.song_id = params[:song_id]\n bs.user_id = params[:id]\n bs.save\n @check = \"SUCCESS\"\n end\n result = {\"id\": bs.id, \"message\": @check}\n render json: result \n end",
"def draw\n @deck = Deck.find(params[:id])\n drawed_cards = @deck.draw_five_cards\n render json: {\n cards: drawed_cards,\n deck_id: @deck.id,\n remaining: @deck.card_codes.count\n }\n end",
"def new_unshuffled\n card_codes = Card.unshuffled_card_codes\n @deck = Deck.create(card_codes: card_codes, player_id: 1, shuffled: false, )\n render json: {\n deck_id: @deck.id,\n shuffled: @deck.shuffled,\n remaining: @deck.card_codes.count\n }\n end",
"def like\n n_prop(:pkt).previous_amount = n_prop(:pkt).amount || 0\n n_prop(:pkt).amount = 1\n create\n end",
"def draw_cards(count)\n self.deck.shift(count)\n end",
"def heart!(comment)\n self.hearts.create!(comment_id: comment.id)\n end",
"def create\n @scribble = Scribble.new(params[:scribble])\n @scribble.posted_by_uid=current_user.beamer_id\n @scribble.posted_by=current_user.first_name+\" \"+current_user.last_name\n @scribble.ups=0\n @scribble.downs=0\n respond_to do |format|\n if @scribble.save!\n format.html { redirect_to root_path }\n format.json { render :json => @scribble, :status => :created, :location => @scribble }\n else\n format.html { redirect_to root_path }\n format.json { render :json => @scribble.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n usr = User.where(fb_id: params[:user_id]).first\n @comment = Comment.new(\n bet_id: params[:bet_id],\n text: params[:text],\n user: usr\n )\n\n if @comment.save\n # make a list of all possible notification recipients\n list = get_bet_opponents(params[:bet_id])\n list.select! {|uid| uid != params[:user_id]} #filter out the guy who made the notification\n push_notify_users(list, \"#{usr.name} commented on #{User.where(fb_id: @comment.bet.owner).first.name}'s bet!\")\n push_notify_user(@comment.bet.owner, \"#{usr.name} commented on your bet!\") unless params[:user_id] == @comment.bet.owner\n render action: 'show', status: :created, location: @comment\n else\n render json: @comment.errors, status: :unprocessable_entity\n end\n end",
"def draw(deck, count = 1)\n @cards = @cards + deck.deal(count)\n reset_scorable_hand\n end",
"def increment_likes\n sneaker = find_sneaker\n sneaker.update(likes: sneaker.likes + 1)\n render json: sneaker\n end",
"def create_json\n @card = Card.new(card_params)\n\n respond_to do |format|\n if @card.limit.nil?\n msg = { id: @card.id, error: 'Must have limit on card' }\n format.json { render json: msg }\n elsif @card.limit <= 0\n msg = { id: @card.id, error: 'Cannot have a zero or negative limit' }\n format.json { render json: msg }\n elsif @card.save\n msg = { id: @card.id, limit: @card.limit }\n format.json { render json: msg }\n else\n format.json { render json: @card.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_emoji(auth, server_id, image, name, reason = nil)\n MijDiscord::Core::API.request(\n :guilds_sid_emojis,\n server_id,\n :post,\n \"#{MijDiscord::Core::API::APIBASE_URL}/guilds/#{server_id}/emojis\",\n { image: image, name: name }.to_json,\n Authorization: auth,\n content_type: :json,\n 'X-Audit-Log-Reason': reason\n )\n end",
"def create\n @scribble = Scribble.new(params[:scribble])\n @scribble.posted_by_uid=current_user.id\n @user = User.find_by_id(current_user.id)\n @profile = @user.profile\n \n\n @scribble.posted_by= @profile.firstname+ \" \"[email protected]\n \n #t = @profile.user.firstname\n #@scribble.posted_by = t\n #current_user.profile \n #@profile = Profile.current_user.id\n #@[email protected]_name+\" \"[email protected]_name\n #@scribble.posted_by=current_user.first_name+\" \"+current_user.last_name\n @scribble.promotes=0\n @scribble.demotes=0\n @scribble.save\n respond_to do |format|\n if @scribble.save\n format.html { redirect_to root_path }\n format.json { render :json => @scribble, :status => :created, :location => @scribble }\n else\n format.html { redirect_to root_path }\n format.json { render :json => @scribble.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def addBlinds()\n s_blind_loc = get_next_player(self.dealer) # location of small blind player\n b_blind_loc = get_next_player(s_blind_loc) # location of big blind player\n # get player data for small and big blind locations\n s_blind_player = get_player(s_blind_loc) # actual players to change money\n b_blind_player = get_player(b_blind_loc)\n # put money from small and big blind players into pot\n put_money(self.small_blind, s_blind_player)\n put_money(self.big_blind, b_blind_player)\n self.current_player = get_next_player(b_blind_loc)\n b_blind_player.save\n s_blind_player.save\n self.save\n end",
"def give_hint()\n \n sleep(2)\n puts \"hint...\"\n sleep(1)\n\n correct_colors = []\n correct_place = 0\n\n #count matching colors\n $computer[\"code\"].map { |value| if $player[\"code\"].include?(value)\n if !correct_colors.include?(value)\n correct_colors.push(value) \n end\n end }\n\n #update object\n $computer[\"correct_colors\"] = correct_colors\n\n #report matching colors \n if correct_colors.length() > 0\n puts \"#{correct_colors.length()} of the colors that the computer chose are accurate...\"\n end \n \n #count matching placement of matching colors\n correct_colors.map { |value| $computer[\"code\"].index(value) == $player[\"code\"].index(value) }.map { |value| if value == true\n correct_place += 1\n end}\n\n #update object\n $computer[\"correct_place\"] = correct_place\n\n puts \"... and #{correct_place} in the correct place\" \n \n sleep(3)\n\n end",
"def update\n render json: Like.update(params[\"id\"], params[\"like\"])\n end",
"def update\n pot = Pot.find_by(game_id: params[:id])\n\n player_list = []\n g = Game.find(pot.game_id)\n player_list << Player.find(g.player1_id) if g.player1_id != nil\n player_list << Player.find(g.player2_id) if g.player2_id != nil\n player_list << Player.find(g.player3_id) if g.player3_id != nil\n player_list << Player.find(g.player4_id) if g.player4_id != nil\n if match?(player_list, g.current_high_bet) == true\n player_list.each do |player|\n pot.total_chips += player.betting\n player.betting = 0\n player.save\n end\n end\n pot.update_attributes(pot_params)\n pot.save\n render json: pot\n end",
"def create\n @rating_reason = RatingReason.new(rating_reason_params)\n\n respond_to do |format|\n if @rating_reason.save\n format.html { redirect_to @rating_reason, notice: 'Rating reason was successfully created.' }\n format.json { render :show, status: :created, location: @rating_reason }\n else\n format.html { render :new }\n format.json { render json: @rating_reason.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @blacklist = Blacklist.new(params[:blacklist])\n\n respond_to do |format|\n if @blacklist.save\n format.html { redirect_to @blacklist, notice: 'Blacklist was successfully created.' }\n format.json { render json: @blacklist, status: :created, location: @blacklist }\n else\n format.html { render action: \"new\" }\n format.json { render json: @blacklist.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add card\r\n # Unlucky for some !\r\n # Sometimes Moody Players won't play.\r\n if rand(40)==13\r\n puts \"Moody player didn't play!\"\r\n else\r\n @card_list.add card\r\n end\r\n end",
"def create\n @black_list = BlackList.new(params[:black_list])\n\n respond_to do |format|\n if @black_list.save\n format.html { redirect_to black_lists_path, notice: 'Balck list was successfully created.' }\n format.json { render json: @black_list, status: :created, location: @black_list }\n else\n format.html { render action: \"new\" }\n format.json { render json: @black_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n json_response(@description.update!(description_params))\n end",
"def rl_insert_comment(count, key)\r\n rl_beg_of_line(1, key)\r\n @rl_comment_text = @_rl_comment_begin ? @_rl_comment_begin : '#'\r\n\r\n if (!@rl_explicit_arg)\r\n rl_insert_text(@rl_comment_text)\r\n else\r\n @rl_comment_len = @rl_comment_text.length\r\n if @rl_comment_text[0,@rl_comment_len] == @rl_line_buffer[0,@rl_comment_len]\r\n rl_delete_text(@rl_point, @rl_point + @rl_comment_len)\r\n else\r\n rl_insert_text(@rl_comment_text)\r\n end\r\n end\r\n\r\n send(@rl_redisplay_function)\r\n rl_newline(1, \"\\n\")\r\n 0\r\n end",
"def heart! \n self.increment!(:hearts_count)\n end",
"def create\n @buzz_name = BuzzName.create_all_buzz_name(@buzz, current_user.id, params[:buzz_name][:name])\n if @buzz_name.valid?\n flash.now[:notice] = 'Buzz Name assigned successfully.'\n else\n msg = []\n flash.now[:error] = @buzz_name.errors.full_messages.each{|e| msg << \"#{e}\" unless msg.include?(e)}\n end\n respond_to do |format|\n format.js { render :template => 'buzz_names/update.js.erb'}\n end\n end",
"def mark!(reason)\n @session.nickserv.mark(self.name, :on, reason)\n end",
"def add_comment(card_id, text, options = {})\n options.update text: text\n create_card_resource card_id, \"actions\", \"comments\", options\n end",
"def with_count(count)\n @count = count\n self\n end",
"def draw\n\t\[email protected]\n\t\t@background_img.draw(0, 0, 0)\n\t\[email protected]{|star| star.draw}\n\t\[email protected](\"Score:#{@player.score}\", 10, 10, ZOrder::UI, 1.0, 1.0, 0xff_ffff00)\n\tend",
"def colorize\n @buffer.create_tag(\"comments\",\n :'foreground' => 'RosyBrown',\n :'weight' => Pango::FontDescription::WEIGHT_BOLD\n )\n\n @buffer.create_tag(\"_\",\n :'weight' => Pango::FontDescription::WEIGHT_BOLD\n )\n end",
"def blocked_by_count(id, scope = Amico.default_scope_key)\n Amico.redis.zcard(\"#{Amico.namespace}:#{Amico.blocked_by_key}:#{scope}:#{id}\")\n end",
"def update\n render json: @facebook_pixel.errors unless @facebook_pixel.update(facebook_pixel_params)\n end",
"def create\n @facebook_pixel = FacebookPixel.new(facebook_pixel_params)\n render json: @facebook_pixel.errors unless @facebook_pixel.save\n end",
"def put_black\n i = 0\n while i<=7 do\n n = Pawn.new([i,6],\"\\u265F\",false)\n put_piece(n)\n i+=1\n end\n n = Rook.new([0,7],\"\\u265C\",false)\n put_piece(n)\n n = Rook.new([7,7],\"\\u265C\",false)\n put_piece(n)\n n = Knight.new([1,7],\"\\u265E\",false)\n put_piece(n)\n n = Knight.new([6,7],\"\\u265E\",false)\n put_piece(n)\n n = Bishop.new([2,7],\"\\u265D\",false)\n put_piece(n)\n n = Bishop.new([5,7],\"\\u265D\",false)\n put_piece(n)\n n = Queen.new([3,7],\"\\u265B\",false)\n put_piece(n)\n n = King.new([4,7],\"\\u265A\",false)\n put_piece(n,true)\n end",
"def show\n @offer = Offer.find_all_by_id_and_playerid(params[:id], params[:playerid])[0]\n\[email protected] = 1\n\[email protected]\n\n\t@notification = Notification.find_all_by_notificationid_and_notification(@offer.id, 'offers')\n\t@notification[0].read = 1\n\t@notification[0].bulb = 0\n\t@notification[0].save\n\t\n\n\t@bulbs = Notification.where('playerid = ?' , params[:playerid]).sum('bulb')\n\t@offer[\"total_bulbs\"] = @bulbs\n\[email protected]\n\t\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @offer }\n end\n end",
"def lose_with_insurance\n self.chips += 2 * self.bet_chips\n self.is_complete = true\n \"Dealer hit Blackjack. A lose for #{name}\n #{name} bought an insurance. Pay 2 times of insurance.\"\n end",
"def mark_drawn!\n # update point tables\n game.point_tables.create(started_at: game.started_at, ended_at: Time.zone.now, result: 'Draw')\n\n # reset board!\n reset_board!\n\n game.update_status(Game::DRAWN)\n end",
"def add_captured_stones(nb, color)\n if nb < 0\n raise \"In add_captured_stones() : cannot capture a negative amount of stones.\"\n end\n if color != 1 and color != 2\n raise \"In add_captured_stones() : \" + color.to_s + \" is not a valid color.\"\n end\n @nb_captured[color - 1] += nb\n # -1 because black player is 1 and his captured stones are counted\n # by nb_captured[0]\n end",
"def create\n \n raise BadRequestError.new('no current character') if current_character.nil?\n raise BadRequestError.new('missing parameter(s)') if params[:character].nil? || params[:character][:id].blank?\n\n receiver = Fundamental::Character.find(params[:character][:id])\n raise BadRequestError.new('cannot like yourself') if receiver == current_character\n\n old_likes = LikeSystem::Like.where('sender_id = ? and receiver_id = ? and created_at > ?',\n current_character, receiver, 1.day.ago).count\n raise ConflictError.new('already sent like!') if old_likes > 0\n \n saved = current_character.add_like_for(receiver) \n\n respond_to do |format|\n if saved \n format.json { render json: {}, status: :ok }\n else\n format.json { render json: {}, status: :not_found }\n end\n end\n end",
"def create\n @c_like = CLike.new(user_id: current_user.id, comment_id: params[:comment_id])\n\n respond_to do |format|\n if @c_like.save\n format.html { redirect_to :back, notice: 'Like was successfully created.' }\n format.json { render json: {status: 'success', like: @c_like, counts: CLike.where(comment_id: @c_like.comment_id).count, liked: true} }\n else\n format.html { render :new }\n format.json { render json: @c_like.errors, status: :unprocessable_entity }\n end\n end\nend",
"def number_for_profile\n # byebug\n # @user=User.where(username: count_params[:username])\n @user = User.find(decode_jwt(cookies.signed[:jwt])[\"user_id\"])\n numfollowers=Follow.where(followee_id: @user.id).count \n numblocked=Block.where(blockee_id: @user.id).count\n render json: {followers: numfollowers, blocked: numblocked}\n end",
"def draw_stat_bonuses\n item.stat_per.each_key do |stat|\n draw_stat_increment(stat)\n end\n end",
"def add_label(card_id, color, options = {})\n create_card_resource(card_id, \"labels\", options.merge(color: color))\n end",
"def create\n json_response(Description.create!(description_params), :created)\n end",
"def add_limiter(id, val)\n add_actions \"AddLimiter(#{id}:#{val})\"\n end",
"def win_jackpot\n @credits += @jackpot\n @jackpot = STARTING_JACKPOT\n puts self.class.message(:jackpot).colorize :green\n end",
"def create_media_comment(id, text, options = {})\n response = post(\"media/#{id}/comments\", options.merge(text: text), signature = true)\n response\n end",
"def tie_with_bj\n self.chips += self.bet_chips\n self.is_complete = true\n \"#{name} hit Blackjack! Dealer hit Blackjack too. Push for #{name}.\"\n end",
"def add_cards\n\t\t3.times { @board << @deck.draw }\n\tend",
"def count\n { value: @count, color: \"gray\" }\n end",
"def add_winner_badges\n\t\trespond_to do |format|\n\t\t\tformat.json{\n\t\t\t\tscrimage = Scrimage.find(params[:scrimage_id])\n\n\t\t\t\tmaxVotes = scrimage.photos.maximum(\"votes\")\n\n\t\t\t\twinningPhotoIDs = scrimage.photos.where(\"votes = ?\", maxVotes)\n\n\t\t\t\tscrimage.winner_id = winningPhotoIDs.first.id\n\t\t\t\t\n\t\t\t\tscrimage.save()\n\n\t\t\t\twinningPhotoIDs.each do |photoID|\n\t\t\t\t\tphoto = Photo.find(photoID)\n\t\t\t\t\tnotification = Notification.new(:user_id => photo.user_id, :message => \"100 Points Awarded - You won the scrimage with your photo, \"+photo.description+\"!\")\n\n\t\t\t\t\t#Ensures that all winners receive points for their winning photos\n\t\t\t\t\tuser = User.find(photo.user_id)\n\t\t\t\t\tuser.update(points: user.points + 100)\n\n\t\t\t\t\tnotification.save()\n\t\t\t\tend\n\n\t\t\t\t#render :json => {:winningPhotoID => winningPhotoIDs} \n\t\t\t\trender :json => {:html => render_to_string({:partial => \"scrimages/displayChildPhotos\", :formats => [:html, :js], :locals => {:scrimage => scrimage, :layout => false}})}\n \t\t\t}\t\t\t\n \t\tend\n\tend",
"def create\n @round = Round.new(round_params)\n @game = Game.find(@round.game_id)\n if @game.rounds.where(round_count: @round.round_count).not(player_id: current_user.id).take.exists?\n o_round = @game.rounds.where(round_count: @round.round_count).not(player_id: current_user.id).take\n @round.character = o_round.character\n else\n @round.character = CHARS[rand(26)]\n end\n respond_to do |format|\n if @round.save\n format.html { redirect_to @round, notice: 'Round was successfully created.' }\n format.json { render :show, status: :created, location: @round }\n else\n format.html { render :new }\n format.json { render json: @round.errors, status: :unprocessable_entity }\n end\n end\n end",
"def print_blackjack_msg(player)\n puts \"Player: #{player.id}. Blackjack!\"\n end",
"def pay_beer\n @player = Player.find(params[:id])\n @player.beer_paid = @player.beer_paid + 1\n @res = @player.save\n \n respond_to do |format|\n format.json {\n render json: {\n :status => @res,\n :player => @player\n }\n }\n end\n end",
"def create\n category = params[:text].scan(/#(\\w+)/).flatten\n\n idea = Idea.create!(\n content: params[:text],\n category: category,\n user: User.find_by(uid: params[:user_id]),\n channel: params[:channel_name],\n stage: \"seed\"\n )\n json = {\n \"text\": \"#{idea.content}\",\n \"attachments\": [\n {\n \"text\": \"#{idea.user.firstname} just logged a new idea!\",\n \"fallback\": \"You are unable to choose a game\",\n \"callback_id\": \"wopr_game\",\n \"color\": \"#3AA3E3\",\n \"attachment_type\": \"default\",\n \"actions\": [\n {\n \"name\": \"game\",\n \"text\": \"endorse\",\n \"type\": \"button\",\n \"value\": \"chess\"\n },\n {\n \"name\": \"game\",\n \"text\": \"Suggest\",\n \"type\": \"button\",\n \"value\": \"maze\"\n },\n ]\n }\n ]\n }\n\n render json: json\n end",
"def mark!(reason)\n @session.chanserv.mark(self.name, :on, reason)\n end",
"def new\n @black_list = BlackList.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @black_list }\n end\n end",
"def deal\n hit = bjdeck.draw\n self.player_hand << hit\n hit = bjdeck.draw\n self.computer_hand << hit\n end",
"def create\n \t#Add player to playground\n @playground = current_playground\n @playgrounds = Playground.all\n #Reset player question variables\n\t@player = Player.find(params[:player_id])\n\[email protected]_attribute(:number_response, 0)\n\[email protected]_attribute(:correct, -1)\n\[email protected]_attribute(:time, 1000)\n\[email protected]_attribute(:winner, -1)\n\t\n\t@game_player = @playground.game_players.build(player: @player)\n\t\n respond_to do |format|\n if @game_player.save\n format.html { redirect_to board_url }\n format.js\n format.json { render json: @game_player, status: :created, location: @game_player }\n else\n format.html { render action: \"new\" }\n format.json { render json: @game_player.errors, status: :unprocessable_entity }\n end\n end\n end",
"def updateservercount(count)\n url = \"https://discordbots.org/api/bots/#{@id}/stats\"\n json = '{\"server_count\":' + count.to_s + '}'\n RestClient.post(url, json, :Authorization => @api, :'Content-Type' => :json)\n \"Successfully set the server count to #{count}\"\n end",
"def create\n response.headers[\"Content-Type\"] = \"text/javascript\"\n @card = @plan.cards.new(card_params)\n @card.save\n $redis.publish('messages.create', @card.to_json)\n end",
"def new\n @blacklist = Blacklist.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @blacklist }\n end\n end",
"def pbFaintBattler(pkmn)\n # reset variables\n @vector.reset\n # setup objects\n poke = @sprites[\"pokemon_#{pkmn.index}\"]\n poke.resetParticles\n databox = @sprites[\"dataBox_#{pkmn.index}\"]\n # play cry\n playBattlerCry(@battlers[pkmn.index])\n self.wait(GameData::Species.cry_length(pkmn.species, pkmn.form), true)\n # begin animation\n pbSEPlay(\"Pkmn faint\")\n poke.showshadow = false\n poke.sprite.src_rect.height = poke.oy\n 16.times do\n poke.still\n poke.sprite.src_rect.y -= 7\n poke.opacity -= 16\n databox.opacity -= 32\n self.wait(1, true)\n end\n clearMessageWindow(true)\n # try to remove low HP BGM\n setBGMLowHP(false)\n # reset src_rect\n poke.src_rect.set(0, 0, poke.bitmap.width, poke.bitmap.height)\n poke.fainted = true\n poke.charged = false\n end",
"def draw\n @updated_blocks.each do |block|\n block.draw(self, [@x_viewport, @y_viewport].to_vec2d)\n end\n @player.draw(self, [@x_viewport, @y_viewport].to_vec2d)\n @font.draw(\"Score: #{@player.score}\", 10, 10, ZOrder::UI,\n 1.0, 1.0, Gosu::Color::WHITE)\n end",
"def bonuses(count = 10)\n params = { command: 'account_bonuses', count: count }\n get('/json.php', params)\n end",
"def post(list_id, name, description = \"\")\n Trello::Card.create(name: name, list_id: list_id, desc: description)\n end",
"def update\n logger.debug(\"Update of #{params[:id]}\")\n use_count = application_user.use_counters.find_or_create_by_name(params[:name])\n use_count.count = params[:count].to_i\n if use_count.save\n render :json => 'done'\n else\n render :json => 'failed', :status => 500\n end\n end",
"def add_captured_stones(nb, color)\n if nb < 0\n raise \"Cannot capture a negative amount of stones.\"\n end\n if color != 1 and color != 2\n raise \"Color '#{color}' is not a valid color.\"\n end\n @nb_captured[color - 1] += nb\n # -1 because black player is 1 and his captured stones are counted\n # by nb_captured[0]\n end",
"def create\n comment = Comment.new(comment_params)\n\n post = Post.find(params[:comment][:post_id])\n post.data[\"comments\"] = post.data[\"comments\"] + 1\n\n if comment.save && post.save\n render json: {\n status: \"success\",\n data: {\n comment: comment.as_json(include: {\n user: {\n only: [:id, :name, :avatar]\n }\n }),\n comments: post.data[\"comments\"]\n }\n }, status: :ok\n else\n render json: comment.errors, status: 404\n end\n end",
"def blocked_count(id, scope = Amico.default_scope_key)\n Amico.redis.zcard(\"#{Amico.namespace}:#{Amico.blocked_key}:#{scope}:#{id}\")\n end",
"def show\n @secret.comments_count = @secret.comments.count\n @secret.likes_count = @secret.likes.count\n end",
"def add_bitch_message(bitch_message_text, &block)\n Logger.d(\"Adding bitch message for user on server : #{bitch_message_text}\")\n \n return if bitch_message_text.length == 0 or bitch_message_text.nil?\n\n json = {\n :message => {\n :abuse => bitch_message_text\n },\n :auth_token => get(:auth_token)\n }.to_json\n\n network_post(CONFIG.get(:add_bitch_message), nil, json, @on_api_call_failed) do |user_object|\n if is_valid_network_user_object?(user_object)\n @data = user_object\n Logger.d(\"Success in @user.add_bitch_message => \" + user_object.to_s)\n serialiaze() # Write the object to persistent storage\n block.call(@data) \n end\n end \n end",
"def update\n @blacklist = Blacklist.find(params[:id])\n\n respond_to do |format|\n if @blacklist.update_attributes(params[:blacklist])\n format.html { redirect_to @blacklist, notice: 'Blacklist was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @blacklist.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n \n \n @batch = Batch.new(params[:batch])\n \n if not params[:batch].has_key? :title\n @batch.title = Time.now.getutc\n end\n \n cards = params[:card]\n\n respond_to do |format|\n if @batch.save\n \n for c in cards\n Card.update c[:id], :status_id=>2, :batch_id => @batch.id\n end\n \n \n format.html { redirect_to @batch, notice: 'Batch was successfully created.' }\n format.json { render json: @batch, status: :created, location: @batch }\n else\n format.html { render action: \"new\" }\n format.json { render json: @batch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n av = rand(21..31)\n @opponent = Opponent.new(name: Faker::JapaneseMedia::DragonBall.character, pv: 100, pa: 100, avatarnum: av)\n @opponent.save\n if @opponent.errors.empty?\n render :index\n else\n # render json: { errors: @opponent.errors }, status: :forbiddden\n render :new\n end\n end",
"def increment \n @animal = Animal.find(params[:id])\n @animal.seen_count += 1\n \n if @animal.save\n render json: @animal\n else\n render json: @animal.errors, status: :unprocessable_entity\n end\n end",
"def ban\n set_lobby\n team = find_team\n name = params[:name]\n @lobby.ban(team, name)\n render :json => { :message => \"#{team_name(team)} has banned #{name}\"}, :status => :ok\n end",
"def pending_with_count(id, scope = Amico.default_scope_key)\n Amico.redis.zcard(\"#{Amico.namespace}:#{Amico.pending_with_key}:#{scope}:#{id}\")\n end",
"def create\n @human = Human.new(params[:human])\n \n respond_to do |format|\n if @human.save\n count = Human.count\n render :text => \"登録完了しました。現在の登録件数は \"+count.to_s+\" 件です。\", :status => 201\n return\n# format.html { redirect_to @human, notice: 'Human was successfully created.' }\n# format.json { render json: @human, status: :created, location: @human }\n else\n format.html { render action: \"new\" }\n format.json { render json: @human.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @blacklist = Blacklist.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @blacklist }\n end\n end",
"def create\n @game = Game.new(game_params)\n @game.rink_id = params[:rink_id]\n respond_to do |format|\n if @game.save\n format.html { redirect_to new_rink_game_url, notice: 'Game was successfully created.' }\n format.json { render :show, status: :created, location: @game }\n else\n format.html { render :new }\n format.json { render json: @game.errors, status: :unprocessable_entity }\n end\n end\n end",
"def kick_params\n params.require(:kick).permit(:tittle, :description, :price, :brand, :condition, :buyer_id, :seller_id, :profile_id, pictures: [])\n end",
"def pokemon_mark_fought(id, number)\n return unless enabled?\n\n id = GameData::Pokemon.get_id(id) if id.is_a?(Symbol)\n return if id >= GameData::Pokemon.all.size\n\n @nb_fought[id] = number.to_i\n end",
"def show\n @black_list = BlackList.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @black_list }\n end\n end",
"def create\n json = ActiveSupport::JSON.decode(params[:player])\n @player = Player.new\n @player.gender = json[\"gender\"]\n @player.username = json[\"username\"]\n @player.uuid = json[\"uuid\"]\n @player.last_location = json[\"location\"]\n @player.player_monsters = [ PlayerMonster.new({ :nickname => json[\"starting_monster\"][\"nickname\"],\n :monster_id => json[\"starting_monster\"][\"id\"],\n :caught_location => json[\"location\"]\n }) ]\n if @player.save\n render :json => { :success => true, :player => @player } , :status => 200\n else\n render :json => { :success => false, :message => @player.errors } , :status => 400\n end\n end",
"def create_player_hash\n @ids.each do |f|\n hash = { id: f, name: Faker::Name.first_name, dice_count: 5, hand: Dice.new(6, 5, true).roll, created_at: Time.now, updated_at: nil }\n @players.push(hash)\n end\n end",
"def comments=(count)\n @comments_count = count\n end",
"def refresh(skip = false)\n last = @lastUsed != 0 ? GameData::Item.get(@lastUsed).id_number : 0\n # format text\n i = last > 0 ? 1 : 0\n name = last > 0 ? GameData::Item.get(@lastUsed).real_name : \"\"\n text = [\"\", \"#{name}\"]\n # clean bitmap\n bmp = pbBitmap(@path + @lastImg)\n icon = pbBitmap(GameData::Item.icon_filename(last))\n bitmap = @sprites[\"pocket4\"].bitmap\n bitmap.clear\n bitmap.blt(0, 0, bmp, Rect.new(0, i*bmp.height/2, bmp.width, bmp.height/2))\n bitmap.blt(28, (bmp.height/2 - icon.height)/2 - 2, icon, icon.rect) if last > 0\n icon.dispose\n # draw text\n dtext = [[text[i], bmp.width/2, 0, 2, @baseColor, Color.new(0, 0, 0, 32)]]\n pbDrawTextPositions(bitmap, dtext); bmp.dispose\n @sprites[\"sel\"].target(@sprites[\"pocket#{@index}\"]) unless skip\n end",
"def notice_json\n render json: {\n notice: {\n id: (@results.first[:hash] rescue nil)\n }\n }\n end",
"def draw\n @player.draw\n Graphics.render_tail\n Graphics.draw_tiles(@font)\n Graphics.display_centered_title(@message.join(\"\"), @small_font)\n Graphics.display_lives(@small_font)\n Graphics.show_emoticon(Settings.mailbox, @font) if @message.join(\"\") == @completed \n if Position.collide?(@active_tile, @player)\n Graphics.erase_emoticon\n Graphics.show_emoticon(Settings.failbox, @font) \n end\n end",
"def update_hand(discard_idx, deck)\n\t\tdiscard_cards = discard_idx.reduce([]) do |discards, idx|\n\t\t\tdiscards << @hand.cards[idx]\n\t\tend\n\t\t# discard cards\n\t\tdiscard_cards.each{ |c| @hand.cards.delete(c) }\n\t\t# replace with new\n\t\tnew_cards = deck.take(discard_cards.size)\n\t\[email protected](*new_cards)\n\t\t\n\t\tputs \"#{name}'s new hand is:\"\n\t\[email protected]\n\t\t\n\t\t@hand\n\tend",
"def create_comment\n @user = User.find(params[:user_id])\n @message = Message.find(params[:message_id])\n @comment = @message.comments.create(params.permit(:content))\n @comment.user = @user\n @comment.user_name = @user.id\n @comment.user_avatar = @user.id\n\n if @comment.save\n response = { \"code\" => 1, \"msg\" => \"Comment Created Successfully\" }\n else\n response = { \"code\" => 0, \"msg\" => \"Comment Can't be created\" }\n end\n\n render json: response\n end",
"def create\n faction_id = params[:guess][:faction_id]\n member_id = Member.where(:faction_id => faction_id).where(:user_id => current_user.id).pluck(:id).first\n if member_id == nil\n render json: {msg: \"ko\"}, status: :unprocessable_entity\n return\n end\n\n game = Game.find_by_id(params[:guess][:game_id])\n if game.kickoff_at < DateTime.now\n render json: {msg: \"ko\"}, status: :unprocessable_entity\n return\n end\n\n result = params[:guess][:result]\n\n # check if there is already a guess\n guess = Guess.find_or_create_by(faction_id: faction_id, member_id: member_id, game_id: game.id)\n guess.result = result\n\n\n if guess.save\n render json: {msg: \"ok\"}, status: :ok\n else\n # todo msg could contain the error message\n render json: {msg: \"ko\"}, status: :unprocessable_entity\n end\n\n end",
"def display_lost_round_message\n puts \"#{current_player.name} lost and their score is now #{current_player.score}\".red\n\n end",
"def update\n add_breadcrumb 'New Blacklist'\n\n respond_to do |format|\n if @blacklist.update(blacklist_params)\n format.html do\n redirect_to @blacklist, notice: 'Blacklist was successfully updated.'\n end\n format.json { render :show, status: :ok, location: @blacklist }\n else\n format.html { render :edit, status: :unprocessable_entity}\n format.json do\n render json: @blacklist.errors, status: :unprocessable_entity\n end\n end\n end\n end",
"def update\n @pokemon_gif&.update(@pokemon_sprite.bitmap)\n # Prevent animation from continuing when message is showing\n return unless super\n update_message\n update_animation\n @counter += 1\n end",
"def create\n @flag = current_user.flags.build(params[:flag])\n\n respond_to do |format|\n if @flag.save\n \n if current_user.facebook_uid and current_user.facebook_connect\n @graph.put_wall_post(\"첫 등반 성공한 선봉장이 되었습니다! 축하해주세요~ with 망고마운틴\", {\n :name => @flag.name, \n :picture => request.protocol + request.host + @flag.photo.url,\n :link => request.protocol + request.host + flag_path(@flag),\n :caption => @flag.user.nickname,\n :description => \"#{@flag.date.strftime(\"%Y년 %m월 %d일\")}-#{@flag.description}\" })\n end\n \n format.html { redirect_to @flag, notice: 'Flag was successfully created.' }\n format.json { render json: @flag, status: :created, location: @flag }\n else\n format.html { render action: \"new\" }\n format.json { render json: @flag.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.51552796",
"0.4701075",
"0.4634198",
"0.44908682",
"0.44851646",
"0.43117198",
"0.43054128",
"0.42076096",
"0.4191373",
"0.41531503",
"0.4138608",
"0.41342637",
"0.41165262",
"0.41022447",
"0.4003534",
"0.3988427",
"0.39752242",
"0.39675748",
"0.39430532",
"0.39313093",
"0.3925273",
"0.39249632",
"0.39082426",
"0.3905428",
"0.3890237",
"0.3877954",
"0.3876752",
"0.38661706",
"0.38603354",
"0.38588634",
"0.3856774",
"0.38529634",
"0.38504675",
"0.3841734",
"0.3831466",
"0.38118514",
"0.3806557",
"0.37996066",
"0.37867743",
"0.37844732",
"0.37820217",
"0.37783343",
"0.37779018",
"0.37775552",
"0.37752655",
"0.37723175",
"0.37710053",
"0.37652",
"0.37649524",
"0.37597504",
"0.37574947",
"0.37572122",
"0.37540203",
"0.37513444",
"0.37508282",
"0.3748849",
"0.3743649",
"0.3736902",
"0.37324217",
"0.37298185",
"0.37295222",
"0.37214214",
"0.3714683",
"0.3713295",
"0.37075388",
"0.37065053",
"0.37056398",
"0.37037182",
"0.37013286",
"0.36969385",
"0.3696862",
"0.36931065",
"0.36788914",
"0.36764115",
"0.367365",
"0.36711645",
"0.36694366",
"0.36650905",
"0.3664528",
"0.36641374",
"0.36619753",
"0.36614192",
"0.36603296",
"0.36589962",
"0.3658091",
"0.36578783",
"0.36548555",
"0.36546457",
"0.36525682",
"0.36493063",
"0.36405295",
"0.36391848",
"0.3632841",
"0.36324367",
"0.36298093",
"0.3626316",
"0.36261824",
"0.36248785",
"0.3623166",
"0.36231214"
] | 0.6180549 | 0 |
Increases _beer_paid_ attribute of _Player_. ==== Required params _id_:: id of _Player_ which attribute _beer_paid_ should be increased. ==== Format JSON | def pay_beer
@player = Player.find(params[:id])
@player.beer_paid = @player.beer_paid + 1
@res = @player.save
respond_to do |format|
format.json {
render json: {
:status => @res,
:player => @player
}
}
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def increase_insurance_premium\n self.insurance_premium += 100\n end",
"def increase_insurance_premium\n self.insurance_premium += 100\n end",
"def increment_points(points)\n self.balance = self.balance.to_i + points.to_i\n self.save\n end",
"def pay!\n update_attributes paid: true, paid_at: DateTime.now\n end",
"def pay\n\n parking = Parking.find(params[:parking_id])\n\n parking.paid = true\n\n time = ((DateTime.now - parking.entry_at.to_datetime) * 24 * 60).to_i\n \n parking.time = time.to_s+\" minutes\"\n\n\t\t\t\tif parking.save\n\t\t\t\t render json: {status: 'SUCCESS', message:'Paid', data:parking},status: :ok\n\t\t\t\telse\n render json: {status: 'ERROR', message:'Not Paid', data:parking.errors},status: :unprocessable_entity\n\t\t\t\tend\n end",
"def pay\n unless self.payment_id\n payment = create_payment\n self.payment_id = payment.id\n self.status = 'paid'\n self.pay_date = Time.now\n self.save\n add_to_balance\n end\n end",
"def mark_paid(user)\n event_user = event_user(user)\n event_user.paid_at = Time.now\n event_user.save\n end",
"def update\n @player = Player.find(params[:id])\n @new_earnings = params[:total_earnings]\n @total_earnings = calculateTotalEarnings(@player, @new_earnings)\n @player.update_attributes(:total_earnings => @total_earnings)\n end",
"def mark_invoice_as_paid\n return unless settled_payment? && valid_response?\n\n paid!\n time = Time.strptime(response['timestamp'], '%s')\n invoice.mark_as_paid_at(time)\n end",
"def do_pay\n self.paid_at = Time.now.utc\n self.send_paid\n end",
"def increase_balance(amount)\n self.balance += amount\n save\n end",
"def add_penalty(penalty_id)\n bill_is_paid = self.paid > 0\n last_generated_count = self.deadline\n added_penalty = AddedPenalty.new({:bill_id => self.id,\n :penalty_id => penalty_id,\n :count => 0,\n :count_generated_at => last_generated_count,\n :bill_is_paid => bill_is_paid})\n added_penalty.save\n end",
"def add_bet_amount(amount_added)\n @bet_amount = bet_amount + amount_added\n end",
"def update_paid\n self.check_paid\n # Use update_columns to skip more callbacks\n self.update_columns(paid: self.paid, paid_amount: self.paid_amount)\n end",
"def points_balance\n user = User.find(params[:user_id])\n transactions = Transaction.sort_user_transactions(params[:user_id]) # sort by created_date\n payers = []\n\n transactions.each do |t|\n payer = payers.find{|p| p[:payer_name] == t.payer_name}\n if payer # if payer already exists in array\n payer[:points] = payer[:points] + t.original_points # add new points to existing balance\n else\n entry = {payer_name: t.payer_name, points: t.original_points} # create a new payer entry and add to array\n payers << entry\n end\n end\n payers.each {|p| p[:points] = p[:points].to_s + \" points\"} # convert to \"100 points\" format\n\n render json: payers\n end",
"def pay\n raise \"Only ajax request.\" if !request.xhr?\n begin\n @order = Order.find(params[:id])\n @order.status = 'Paid'\n if @order.save\n head :ok\n else\n head :unprocessable_entity\n end\n rescue\n head :unprocessable_entity\n end\n end",
"def update\n pot = Pot.find_by(game_id: params[:id])\n\n player_list = []\n g = Game.find(pot.game_id)\n player_list << Player.find(g.player1_id) if g.player1_id != nil\n player_list << Player.find(g.player2_id) if g.player2_id != nil\n player_list << Player.find(g.player3_id) if g.player3_id != nil\n player_list << Player.find(g.player4_id) if g.player4_id != nil\n if match?(player_list, g.current_high_bet) == true\n player_list.each do |player|\n pot.total_chips += player.betting\n player.betting = 0\n player.save\n end\n end\n pot.update_attributes(pot_params)\n pot.save\n render json: pot\n end",
"def raise_bet(amount)\r\n puts \"\\n%33s\\n\" % \"Player ##{player_id+1} raised $#{amount}.\"\r\n @table.add_player_bet(self, @table.current_bet + amount)\r\n end",
"def paid\n\t\tif params[:confirm].to_i == 1\n\t\t\tif @order.armor_enabled?\n\t\t\t\[email protected]_testing_set_to_paid\n\t\t\telse #is a prepay order\n\t\t\t\[email protected]_mark_as_paid\n\t\t\tend\n\t\t\tif @order.errors.any?\n\t\t\t\tflash.now[:notice] = @order.errors.full_messages\n\t\t\telse\n\t\t\t\t@success = true\n\t\t\t\tsleep(5) if @order.armor_enabled? #pause to allow update of status from webhook if armor\n\t\t\tend\n\t\tend\n\t\trespond_to do |format|\n\t\t\tformat.html { redirect_to order_url(@order) }\n\t\t\tformat.js\n\t\tend\n\tend",
"def deal_cash\n self.game_players.each do |player|\n player.cash = 6000\n player.save\n end\n end",
"def set_paid\n if unpaid_amount > 0 and not paid\n payment = Payment.create(\n invoice_id: self.id,\n date: Date.today,\n amount: unpaid_amount)\n self.save\n end\n end",
"def buy!\n company = companies.unowned.first\n certificate = company.certificates.first\n cost = company.cost\n player = self.active_player\n\n if player.wallet < cost\n return \"Player doesn't have enough\"\n end\n\n player.wallet -= cost\n player.save\n\n company.director = player\n company.save\n\n certificate.player = player\n certificate.save\n\n self.bank += cost\n self.save\n\n next_player!\n\n # Save who normally would have the active player, because we might go into bidding\n self.priority = self.active_player\n self.passes = 0\n self.save\n\n next_auction!\n\n \"#{company.name} was purchased for #{cost} G. by #{player.name}\"\n end",
"def give_bonus player\n player.add_1_life\n end",
"def pay\n @order = Order.find(params[:id])\n if(@order.status == \"PLACED\")\n @order.status = \"PAID\"\n if @order.save\n respond_to do |format|\n format.html { redirect_to @order, notice: 'Paid!'}\n format.json { render json: @order, status: :accepted, location: @order }\n end\n end\n else\n respond_to do |format|\n format.html { redirect_to @order, notice: 'Order must first be placed before being paid.' }\n format.json { render json: @order.errors, status: :method_not_allowed }\n end\n end\n end",
"def pays_players\n self.players.inject(0) {|sum, player| sum += player.pay}\n end",
"def updatePendingPay\n if !(Integer(params[:id]) rescue false)\n renderError(\"Not Acceptable (Invalid Params)\", 406, \"The parameter id is not an integer\")\n return -1\n end\n options = {\n :body => params.to_json,\n :headers => {\n 'Content-Type' => 'application/json'\n }\n }\n resul = HTTParty.get(\"http://192.168.99.101:4055/lists/\"+params[:id])\n user = resul[\"user_id\"]\n if user == (@current_user[\"id\"]).to_i\n results = HTTParty.put(\"http://192.168.99.101:4055/lists/\"+params[:id], options)\n if results.code == 201\n head 201\n else\n render json: results.parsed_response, status: results.code\n end\n else\n renderError(\"Not Acceptable (Invalid Params)\", 403, \"The user does not have permmision\")\n end\n end",
"def set_paid\n @paid = Paid.find(params[:id])\n end",
"def has_paid (driver, person, amount)\n # debt - amount\n end",
"def mark_paid\n @invoice.update(:paid => true)\n redirect_to :back\n end",
"def si_update_approved_amount\n amount = params[:amount].to_f / 10000\n invoice_id = params[:invoice]\n tbl = params[:tbl]\n debt = SupplierInvoice.find(invoice_id).debt rescue -1\n not_yet_approved = SupplierInvoice.find(invoice_id).amount_not_yet_approved rescue -1\n amount = (amount > debt || amount > not_yet_approved) ? '$err' : number_with_precision(amount.round(4), precision: 4)\n @json_data = { \"amount\" => amount.to_s, \"tbl\" => tbl.to_s }\n render json: @json_data\n end",
"def perform()\n players = Player.all\n\n players.each do |player|\n player.money = player.money + 10000\n player.save\n end\n end",
"def dancer_has_paid_dues(dancer_id)\n dancer_finance = Finance.find(dancer_id)\n dancer_finance.dues = true\n dancer_finance.dues_approved = current_user.username\n dancer_finance.dues_updated = Time.now\n dancer_finance.save\n redirect_to :back, alert: \"#{dancer_finance.dancer.name} has paid their dues.\"\n end",
"def pay_in(balance)\n @balance += balance\nend",
"def update\n @player_earning = PlayerEarning.find(params[:id])\n\n respond_to do |format|\n if @player_earning.update_attributes(params[:player_earning])\n format.html { redirect_to @player_earning, notice: 'Player earning was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_earning.errors, status: :unprocessable_entity }\n end\n end\n end",
"def get_paid(salary)\n self.bank_account += salary\n self.happiness += 1\n \"all about the benjamins\"\n end",
"def put_money(amount, player)\n if amount > player.money\n amount = player.money\n end\n if amount + player.in_pot_current > self.high_bet # if player is new high bet (bets more than current highest)\n self.high_bet = amount + player.in_pot_current\n self.high_better = player.location\n end\n player.money -= amount # puts money in correct places and takes from player's pot\n player.in_pot_current += amount\n player.in_pot_hand += amount\n self.pot += amount\n player.save\n self.save\n end",
"def update_pending\n @pending_amount = self.class.count_money @pending_money\n end",
"def update_advance_fee_wallet\n if self.wallet_amount_applied == true\n AdvanceFeeDeduction.destroy_deduction_record(self.id)\n advance_fee_wallet = self.payee.advance_fee_wallet\n advance_fee_wallet.amount = advance_fee_wallet.amount.to_f + self.wallet_amount.to_f\n advance_fee_wallet.save\n end\n end",
"def update\n if params[:draft]\n @player.claimed_by = 1\n elsif params[:remove]\n @player.claimed_by = 0\n else\n raise \"Expecting draft or remove\"\n end\n @player.claim_time = Time.now\n\n @player.save!\n respond_to do |format|\n format.html { redirect_to players_url, notice: 'Player was successfully updated.' }\n format.json { head :no_content }\n end\n end",
"def add_buyer(c_id)\n metadata[:buyers] ||= []\n\n metadata[:buyers] |= Array(c_id.to_i)\n self.save\n end",
"def adjust_num_from_amount_paid(amount_paid)\n return true if amount_paid == 0\n self.num += amount_paid / self.price\n self.save\n end",
"def pay_all_bills\n #self.appointments.update_all(cost: 0)\n self.appointments.each {|a| a.paid}\n end",
"def give_bonus player\n player.add_weapon(Vibrant_Weapon.new(@window, player))\n end",
"def send_bonus!(amt)\n mturk_bonus_assignment(self.mturk_assignment_id, self.mturk_worker_id, amt)\n self.update_attributes(:bonus => amt)\n end",
"def bill\n wallet = self.subscriber.default_wallet\n transaction = wallet.transactions.build(\n date: Time.now,\n expence: self.calculate_amount,\n description: self.plan.name\n ).save\n billing = self.billings.build(\n amount: wallet.total,\n description: \"Test\"\n ).save\n wallet.transactions.pending.update_all billing_id: billing\n end",
"def update\n\n debt = Debt.find_by_id(params[:id])\n payment = BigDecimal( debt_params[:amount] )\n\n # Since the debted user is paying the indebted user,\n # we can simulate this as the indebted user \"owing\"\n # the debted user (a.k.a. the debt owner) the payed off\n # debt.\n Debt.settleDebt(debt.owner, debt.indebted, payment)\n flash[:success] = \"Debt has been paid successfully.\"\n redirect_to root_url\n end",
"def pay\n @group = Group.find(params[:group_id])\n @gexpense = Gexpense.find(params[:gexpense_id])\n @member_expense = MemberExpense.find(params[:id])\n\n @member_expense.update_attribute(:paid, true)\n \n redirect_to request.referer\n end",
"def update\n respond_to do |format|\n if @rental.update(rental_params)\n Bike.where(:id => @rental.bike_id).update(available: 't',:bikestand_id =>@rental.end_stand_id)\n @rental.update :end_time => Time.now\n @rental.update :cost => ((Time.now - @rental.start_time) / 60 / 60) * 2\n format.html { redirect_to rental_pay_path(@rental), notice: 'Thank you for using bShare!' }\n format.json { render :show, status: :ok, location: @rental }\n else\n format.html { render :edit }\n format.json { render json: @rental.errors, status: :unprocessable_entity }\n end\n end\n end",
"def buyer_chosen(c_id)\n pending = true\n\n self.buyer = User.find(c_id)\n self.save\n end",
"def add_to_balance\n self.user.balance += self.price\n self.user.save\n end",
"def pay_workers\r\n\t\t@cash -= (@sellers + @thieves)*10\r\n\tend",
"def paid_params\n params.require(:paid).permit(:pay)\n end",
"def give_item(id, amount)\n item = $data_items[id];\n $game_party.gain_item(item, amount)\n end",
"def update\n respond_to do |format|\n if @paid.update(paid_params)\n format.html { redirect_to @paid, notice: 'Paid was successfully updated.' }\n format.json { render :show, status: :ok, location: @paid }\n else\n format.html { render :edit }\n format.json { render json: @paid.errors, status: :unprocessable_entity }\n end\n end\n end",
"def reward\n business.add_to_balance(amount)\n end",
"def pay_blinds\n @dealer.pay(@game.small_blind)\n @under_the_gun.pay(@game.big_blind)\n end",
"def create_bepaid_bill\n # Don't touch real web services during of test database initialization\n return if Rails.env.test?\n\n user = self\n\n bp = BePaid::BePaid.new Setting['bePaid_baseURL'], Setting['bePaid_ID'], Setting['bePaid_secret']\n\n amount = user.monthly_payment_amount\n\n #amount is (amoint in BYN)*100\n bill = {\n request: {\n amount: (amount * 100).to_i,\n currency: 'BYN',\n description: 'Членский взнос',\n email: '[email protected]',\n notification_url: 'https://hackerspace.by/admin/erip_transactions/bepaid_notify',\n ip: '127.0.0.1',\n order_id: '4444',\n customer: {\n first_name: 'Cool',\n last_name: 'Hacker',\n },\n payment_method: {\n type: 'erip',\n account_number: 444,\n permanent: 'true',\n editable_amount: 'true',\n service_no: Setting['bePaid_serviceNo'],\n }\n }\n }\n req = bill[:request]\n req[:email] = user.email\n req[:order_id] = user.id\n req[:customer][:first_name] = user.first_name\n req[:customer][:last_name] = user.last_name\n req[:payment_method][:account_number] = user.id\n\n begin\n res = bp.post_bill bill\n logger.debug JSON.pretty_generate res\n rescue => e\n logger.error e.message\n logger.error e.http_body if e.respond_to? :http_body\n user.errors.add :base, \"Не удалось создать счёт в bePaid, проверьте лог\"\n end\n end",
"def call_bet\r\n call_amount = @table.current_bet\r\n (padding,pronoun) = self.is_a?(User) ? [30,\"You\"] : [33,\"Player ##{player_id+1}\"]\r\n puts \"\\n%#{padding}s\\n\" % \"#{pronoun} called $#{call_amount}.\"\r\n @table.add_player_bet(self, call_amount)\r\n end",
"def add_paid_contribution_time time_amount\n if current_paid_contributer?\n self.paid_contributer_until += time_amount\n else\n self.paid_contributer_until = Time.now + time_amount\n end\n add_contribution_time time_amount\n save\n end",
"def set_postpaid\n postpaid = 1\n end",
"def gain(money)\n\t\tself.bank_amount += money\n\t\tself.save\n\tend",
"def set_payment_increase\n @payment_increase = PaymentIncrease.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @contract.daily_premium_prices.push(params[:daily_premium_prices][0])\n @contract.update_attributes(:premium => contract_params[:premium], :count => contract_params[:count])\n @contract.save\n format.html { redirect_to @contract, notice: 'Contract was successfully updated.' }\n format.json { render :show, status: :ok, location: @contract }\n else\n format.html { render :edit }\n format.json { render json: @contract.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_ledger\n self.create_ledger(amount: self.amount, customer: self.customer, date: self.date, received: 0)\n end",
"def bet(amount, enemy_id)\n begin\n transaction do\n new_bet = Bet.new(:amount => amount, :enemy_id => enemy_id, :channel_account_id => id)\n self.bets << new_bet\n self.balance -= amount\n self.status = STATUS_BETTING \n \n new_bet.save!\n self.save!\n end\n rescue ActiveRecord::RecordInvalid\n false\n end\n end",
"def set_bidder_amount\n @bidder_amount = BidderAmount.find(params[:id])\n end",
"def update_status_paid()\n if stock_available?\n # Reduce stock once paid to prevent someone creating lots of unpaid orders which would stop others making purchases.\n # This should really be in a transaction but unlikely to have problems due to race condition.\n update!(status: PAID)\n ScriptLog.info(\"order_id #{id} is now PAID #{btc_address.address}:#{payment_received}\")\n reduce_product_stock()\n ScriptLog.info(\"order_id #{id} product_id #{product.id} stock reduced to #{product.stock}\")\n else\n update!(status: PAID_NO_STOCK)\n ScriptLog.info(\"order_id #{id} is now PAID_NO_STOCK #{btc_address.address}:#{payment_received}\")\n end\n end",
"def update\n respond_to do |format|\n if @beer.update(beer_params)\n Venue.where(id: @beer.venue_id).first.update_attribute(:venue_verify, Time.now)\n format.html { redirect_to :venue_beer_list, notice: 'Beer was successfully updated.' }\n format.json { render :venue_beer_list, status: :ok, location: @beer }\n else\n format.html { render :edit }\n format.json { render json: @beer.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_invested\n self.invested_amount = self.investments.map(&:amount).sum\n self.goal_investment = 0 unless self.goal_investment\n self.equity_offered = 0 unless self.equity_offered\n self.save\n end",
"def add_score\n transaction do\n self.player.points = self.player.points + 1\n if self.player.save\n self.player.team.score = self.player.team.score + 1\n self.player.team.save\n end\n self.player.inc_score_stats\n end\n end",
"def update\n @feed_item = FeedItem.find(params[:id])\n @feed_item.approver_email = current_user.email\n\n respond_to do |format|\n if @feed_item.update_attributes(params[:feed_item])\n @feed_item.approval_votes += 1\n @feed_item.save\n @feed_item.givePoints(@feed_item.user_email, @feed_item.approver_email, @feed_item)\n format.html { redirect_to @feed_item, notice: 'Feed item was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_points\n user = User.find(params[:user_id])\n\n if transaction_params[:points] < 0 # This is for negative additions - possible input per instructions\n payer_balance = user.payer_points_subtotal(transaction_params[:payer_name])\n points_to_deduct = transaction_params[:points] * -1\n # Do not deduct more points than user's total payer sub-balance\n if payer_balance - points_to_deduct < 0 # must be enough points from given payer in the account\n render json: {error: \"Can't deduct more than user's total payer sub-balance\"}, status: :not_acceptable\n else\n removed_points = Transaction.deduct_points(user.id, points_to_deduct, transaction_params[:payer_name])\n removed_points.size > 0 ? (render json: removed_points, each_serializer: RemovedTransactionSerializer) : (render json: removed_transactions.to_json)\n end\n\n else # Positive additions - usual use case\n transaction = user.transactions.new(payer_name: transaction_params[:payer_name], points: transaction_params[:points], original_points: transaction_params[:points])\n if transaction.valid?\n transaction.save\n render json: transaction, serializer: TransactionShowSerializer\n else\n render json: {errors: transaction.errors}, status: :bad_request\n end\n end\n end",
"def pokemon_fought_inc(id)\n return unless enabled?\n\n id = GameData::Pokemon.get_id(id) if id.is_a?(Symbol)\n return if id >= GameData::Pokemon.all.size\n\n @nb_fought[id] = @nb_fought[id].to_i.next\n end",
"def updateMoney(money, id)\n parameters={money: money}\n options = {\n :body => parameters.to_json,\n :headers => {\n 'Content-Type' => 'application/json'\n }\n }\n results = HTTParty.put(\"http://192.168.99.101:4051/users/update_money?id=\" + id.to_s , options)\n return results\n end",
"def update\n @payment = Payment.find(params[:id])\n @payment.delayed = params[:delayed]\n @payment.repayment = params[:repayment]\n @payment.paid = true\n @payment.save\n\n redirect_to company_root_path\n end",
"def strike_update(live_update)\n client.post(\"/api/live/#{read_attribute(:id)}/strike_update\", id: live_update.name)\n end",
"def add_new_bid\n @product = Product.find(params[:id])\n bid = Bid.create\n\n if params[:max_bid].to_i >= @product.price\n @product.update_attributes(end_date: Time.now)\n respond_to do |format|\n format.html { redirect_to @product, notice: 'Purchased' }\n format.json { render :show, status: :ok, location: @product }\n end\n elsif params[:max_bid].to_i < @product.current_price\n respond_to do |format|\n format.html { redirect_to @product, alert: 'Your bid must be higher than the starting price !' }\n format.json { render :show, status: :ok, location: @product }\n end\n else\n bid.max_bid = params[:max_bid]\n bid.product_id = @product.id\n bid.user_id = current_user.id\n bid.save\n respond_to do |format|\n format.html { redirect_to @product, notice: 'Your bid has been placed' }\n format.json { render :show, status: :ok, location: @product }\n end\n end\n end",
"def pot_adjustment\n @committed += @active_players[0].current_bet unless @active_players[0].folded\n @pot_size += @active_players[0].current_bet\n @active_players[0].chip_stack -= @active_players[0].current_bet\n @active_players[0].acted = true\nend",
"def buy(amount)\n @bought_amount += amount if amount_remaining >= amount\n end",
"def update\n @crate = Crate.find(params[:id])\n\n paid = @crate.paid\n\n respond_to do |format|\n if @crate.update_attributes(params[:crate])\n \n # Only sending the mail, in case the paid date was newly added.\n if (paid.nil? == true) && (@crate.paid.nil? == false)\n CratesNotifier.crate_paid(@crate).deliver\n end\n\n format.html { redirect_to @crate, :notice => 'Crate was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @crate.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def add_pending(value)\n raise_invalid_coin! if @pending_money[value.to_s].nil?\n @pending_money[value.to_s] += 1\n update_pending\n end",
"def paid\r\n #if @notification.acknowledge # check if it’s genuine Robokassa request\r\n #@user.approve! # project-specific code\r\n render :text => @notification.success_response\r\n @payment.approve!\r\n #else\r\n #head :bad_request\r\n #end\r\n end",
"def change_delivery_drink_quantity\n # get data to add/update\n @data = params[:id]\n @data_split = @data.split(\"-\")\n @add_or_subtract = @data_split[0]\n @user_delivery_id = @data_split[1]\n \n # get User Delivery info\n @account = Account.find_by_id(current_user.account_id)\n @user_subscription = UserSubscriptionn.where(account_id: current_user.account_id, currently_active: true).first\n @user_delivery_info = UserDelivery.find_by_id(@user_delivery_id)\n @delivery = Delivery.find_by_id(@user_delivery_info.delivery_id)\n @inventory = Inventory.find_by_id(@user_delivery_info.inventory_id)\n \n # adjust drink quantity, price and inventory\n @original_quantity = @user_delivery_info.quantity\n @drink_price = @user_delivery_info.inventory. + @user_subscription.pricing_model\n @current_inventory_reserved = @inventory.reserved\n if @add_or_subtract == \"add\"\n # set new quantity\n @new_quantity = @original_quantity + 1\n \n #set new price totals\n @original_subtotal = @delivery.subtotal\n @new_subtotal = @original_subtotal + @drink_price\n @new_sales_tax = @new_subtotal * @account.delivery_zone.excise_tax\n @new_total_price = @new_subtotal + @new_sales_tax\n \n # update reserved inventory \n @new_inventory_reserved = @current_inventory_reserved + 1\n @inventory.update(reserved: @new_inventory_reserved)\n\n # update user delivery info\n @user_delivery_info.update(quantity: @new_quantity)\n \n else\n # set new quantity\n @new_quantity = @original_quantity - 1\n \n #set new price totals\n @original_subtotal = @delivery.subtotal\n @new_subtotal = @original_subtotal - @drink_price\n @new_sales_tax = @new_subtotal * @account.delivery_zone.excise_tax\n @new_total_price = @new_subtotal + @new_sales_tax\n \n # update reserved inventory \n @new_inventory_reserved = @current_inventory_reserved - 1\n @inventory.update(reserved: @new_inventory_reserved)\n \n # update user delivery info\n @user_delivery_info.update(quantity: @new_quantity)\n end\n \n # update delivery info and note a confirmation email should be sent\n @delivery.update(subtotal: @new_subtotal, sales_tax: @new_sales_tax, total_drink_price: @new_total_price, delivery_change_confirmation: false)\n \n # add change to the customer_delivery_changes table\n @customer_delivery_change = CustomerDeliveryChange.where(user_delivery_id: @user_delivery_id).first\n if !@customer_delivery_change.blank?\n @customer_delivery_change.update(new_quantity: @new_quantity, change_noted: false)\n else\n @new_customer_delivery_change = CustomerDeliveryChange.new(user_id: current_user.id, \n delivery_id: @user_delivery_info.delivery_id,\n user_delivery_id: @user_delivery_id,\n beer_id: @user_delivery_info.beer_id,\n original_quantity: @original_quantity,\n new_quantity: @new_quantity,\n change_noted: false)\n @new_customer_delivery_change.save!\n end\n \n # set new delivery details and delivery info\n @next_delivery = UserDelivery.where(delivery_id: @user_delivery_info.delivery_id)\n @delivery = Delivery.find_by_id(@user_delivery_info.delivery_id)\n \n # count number of drinks in delivery\n @drink_count = @next_delivery.sum(:quantity)\n # count number of drinks that are new to user\n @next_delivery_cooler = 0\n @next_delivery_cellar = 0\n @next_delivery_small = 0\n @next_delivery_large = 0\n # cycle through next delivery drinks to get delivery counts\n @next_delivery.each do |drink|\n @quantity = drink.quantity\n if drink.cellar == true\n @next_delivery_cellar += (1 * @quantity)\n else\n @next_delivery_cooler += (1 * @quantity)\n end\n if drink.large_format == true\n @next_delivery_large += (1 * @quantity)\n else\n @next_delivery_small += (1 * @quantity)\n end\n end \n \n respond_to do |format|\n format.js\n end # end of redirect to jquery\n end",
"def set_payer\n @payer = Payer.find(params[:id])\n end",
"def update\n @bill = Bill.find(params[:id])\n @bill.update(bill_params)\n @bill.price = total(@bill)\n @bill.status = 'pending'\n @bill.save\n redirect_to admins_url\n end",
"def assign_beer_to_line\n if (beer_id)\n beer = Beer.find(beer_id)\n previous_stock = beer.stock\n beer.stock = previous_stock -1\n beer.save\n end\n end",
"def increment_quantity\n self.quantity_needed += self.quantity\n save\n end",
"def update\n @bet = Bet.find(params[:id])\n @line = @bet.line\n redirect_to lines_path and return if @line.event.started?\n current_bet_size = @bet.amount\n @portfolio = @bet.portfolio\n current_balance = @portfolio.cash\n\n respond_to do |format|\n if @bet.update_attributes(params[:bet])\n @portfolio.update_attributes(:cash => current_balance + current_bet_size - params[:bet][:amount].to_i)\n\n format.html { redirect_to @bet, notice: 'Bet was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bet.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_user_balance\n user.decrement(:loyalty_points_balance, loyalty_points)\n user.save!\n end",
"def withdraw!(amount, destination_account_id, dedupe_id = SecureRandom.uuid)\n data = {\n amount: amount,\n destination_account_id: destination_account_id,\n dedupe_id: dedupe_id,\n }\n\n response = Monzo.client.put(\"/pots/#{@id}/withdraw\", data)\n parsed_response = parse_response(response)\n update_self(parsed_response)\n end",
"def update_bid(user, new_bid)\r\n available_credits_for_update = (self.bid.last.value + user.credits)\r\n if new_bid > available_credits_for_update\r\n raise TradeException, \"Not enough money!\"\r\n elsif new_bid <= self.bid.last.value\r\n raise TradeException, \"You've already given a higher bid!\"\r\n else\r\n additional_credit_cost = (new_bid - self.bid.last.value)\r\n user.credits -= additional_credit_cost\r\n user.credits_in_auction += additional_credit_cost\r\n self.bid.last.value = new_bid\r\n self.invariant\r\n end\r\n end",
"def update\n respond_to do |format|\n if @bid.update(bid_params)\n @bid.maintenance_request = MaintenanceRequest.find_by_id(params[:bid][:maintenance_request_id])\n @user = User.find_by_id(@bid.maintenance_request.user_id)\n @bid.contractor = current_contractor\n if @bid.price\n @bid.payout = @bid.price * 0.90\n end\n @bid.save\n format.html { redirect_to @bid, notice: 'Bid was successfully updated.' }\n format.json { render :show, status: :ok, location: @bid }\n else\n @bid = Bid.new\n @maintenance_request = MaintenanceRequest.find_by_id(params[:maintenance_request_id])\n format.html { render :edit }\n format.json { render json: @bid.errors, status: :unprocessable_entity }\n end\n end\n end",
"def receive_winnings(amount)\n @bankroll += amount\n end",
"def add_money\n @total += fee\n end",
"def create\n @team = Team.new(team_params)\n # Add 1000 to the newly created team and subtract 1000 from the team that the user left\n current_team = Team.find(current_user.team_id)\n current_team.update_attribute(:balance, current_team.balance -= 1000)\n @team.update_attribute(:balance, @team.balance += 1000)\n\n\n respond_to do |format|\n if @team.save\n current_user.update_attribute(:team_id, @team.id)\n format.html { redirect_to @team, notice: 'Team was successfully created.' }\n format.json { render :show, status: :created, location: @team }\n else\n format.html { render :new }\n format.json { render json: @team.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pre_pay_offered\n end",
"def bill_paid\n bill_ids_to_update = []\n bills = Bill.includes(:bill_splits)\n\n bill_paid = true\n bills.each do |bill|\n bill.bill_splits.each do |split|\n bill_paid = bill_paid && split.recipient_paid\n end\n\n if bill_paid\n bill_ids_to_update.push(bill.id)\n end\n\n # Reset bill_paid back to true for when you go through first billsplit that has a false recipient_paid\n bill_paid = true\n end\n\n bill_ids_to_update\n\n end",
"def get_paid(salary)\n self.bank_account += salary\n return \"all about the benjamins\"\nend",
"def info_premium\n render json: { value: (PropertyBuyer::PREMIUM_COST*100) }, status: 200\n end",
"def charge_and_update_credits\n\t\tresponse = PaymentHelper.create_transaction(self.parker, self)\n\t\tself.leaver.add_credits\n\t\tunless response[:error]\n\t\t\tself.parker.charge_credits(response[:amount_charged] / 100)\n\t\tend\n\tend"
] | [
"0.58982944",
"0.58711165",
"0.5836379",
"0.58351606",
"0.57814634",
"0.5766293",
"0.5667446",
"0.5664226",
"0.5623893",
"0.5562069",
"0.55351895",
"0.55323076",
"0.5525465",
"0.5524702",
"0.54698724",
"0.5468731",
"0.5445076",
"0.5423665",
"0.5415927",
"0.5410741",
"0.5384953",
"0.53817564",
"0.5355422",
"0.53267133",
"0.53156805",
"0.5293115",
"0.5287493",
"0.5271363",
"0.5250765",
"0.52469695",
"0.52148527",
"0.5213009",
"0.5181504",
"0.517694",
"0.51720047",
"0.516635",
"0.51654714",
"0.51496613",
"0.51477426",
"0.51476806",
"0.51405144",
"0.5127542",
"0.5118373",
"0.5081929",
"0.5076452",
"0.50755167",
"0.5060328",
"0.5054697",
"0.5054374",
"0.50447196",
"0.5036306",
"0.502987",
"0.5024223",
"0.5012199",
"0.50117075",
"0.49904644",
"0.49835446",
"0.49827582",
"0.4976297",
"0.49749282",
"0.49645835",
"0.49632838",
"0.4962256",
"0.49567875",
"0.4956345",
"0.49543867",
"0.4953012",
"0.49513602",
"0.49474654",
"0.4946802",
"0.4946452",
"0.49334478",
"0.4931447",
"0.4926327",
"0.49225017",
"0.49208704",
"0.491747",
"0.49155387",
"0.49126166",
"0.4907344",
"0.4905136",
"0.49006972",
"0.48963228",
"0.48931715",
"0.489018",
"0.48868087",
"0.48851705",
"0.4884857",
"0.48783493",
"0.48756778",
"0.48754972",
"0.48754534",
"0.48744276",
"0.487414",
"0.48716405",
"0.48692814",
"0.48659095",
"0.48638994",
"0.4863308",
"0.4862462"
] | 0.8105451 | 0 |
Realizing the actual importance of code formatting | def fed
( p p )
p?a a?p
q= p q =p
p %%.....%% q
dne end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def beautify; end",
"def beautify; end",
"def code_format_print(code)\n indent = 0\n l = 1\n code.each_line do |ln|\n ln = ln.strip\n if(ln.match(/^end/))\n indent -= 4\n end\n indent = 0 if indent < 0\n ll = \" \"\n if(l<10)\n ll = \"00#{l} \"\n elsif(l<100)\n ll = \"0#{l} \"\n else\n ll = \"#{l} \"\n end\n l += 1\n\n puts ll + \" \"*indent + ln\n\n if(ln.match(/^class/))\n indent += 4\n elsif(ln.match(/^def/))\n indent += 4\n elsif(ln.match(/do$/))\n indent += 4\n end\n\n if(ln.match(/end$/) && !ln.match(/^end/))\n indent -= 4\n end\n end\nend",
"def format_code strip = true\n format_ruby self.code, strip\n end",
"def format_source(source); end",
"def formatted_source_file(source_file); end",
"def indentation; end",
"def indentation; end",
"def prettify\n @code.gsub(/(.{4})/, '\\1 ').strip\n end",
"def formatter; end",
"def formatter; end",
"def formatter; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def formatters; end",
"def formatFunction(theLines)\n\n\treplaceVoids(\t\ttheLines);\n\tspaceFirstComment(\ttheLines);\n\nend",
"def format!; end",
"def format_message\n return @format_message if @format_message\n\n @format_message = self.message.dup\n\n if self.line\n @format_message << \" near line #{self.line}\"\n end\n\n if self.code\n @format_message << \": #{format_code}\"\n end\n\n @format_message\n end",
"def formats; end",
"def formats; end",
"def formatClass(theLines)\n\n\treplaceVoids(\t\ttheLines);\n\tspaceMethods(\t\ttheLines);\n\tindentMembers(\t\ttheLines);\n\talignParams(\t\ttheLines);\n\talignSpecifiers(\ttheLines);\n\nend",
"def indent()\n file = Tempfile.new(\"out\")\n infile = Tempfile.new(\"in\")\n file.write(self.to_s)\n file.flush\n bufc = \"FOO\"\n\n tmppos = @pos\n\n message(\"Auto format #{@fname}\")\n\n if [\"chdr\", \"c\", \"cpp\"].include?(get_file_type())\n\n #C/C++/Java/JavaScript/Objective-C/Protobuf code\n system(\"clang-format -style='{BasedOnStyle: LLVM, ColumnLimit: 100, SortIncludes: false}' #{file.path} > #{infile.path}\")\n bufc = IO.read(infile.path)\n elsif get_file_type() == \"Javascript\"\n cmd = \"clang-format #{file.path} > #{infile.path}'\"\n debug cmd\n system(cmd)\n bufc = IO.read(infile.path)\n elsif get_file_type() == \"ruby\"\n cmd = \"rufo #{file.path}\"\n debug cmd\n system(cmd)\n bufc = IO.read(file.path)\n else\n return\n end\n self.update_content(bufc)\n center_on_current_line #TODO: needed?\n file.close; file.unlink\n infile.close; infile.unlink\n end",
"def indent=(_arg0); end",
"def lines_of_code; end",
"def lines_of_code; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent()\n #This is a stub, used for indexing\n end",
"def format_source(source)\n source.chomp!\n indent = source.split(/\\r?\\n/).last[/^([ \\t]*)/, 1].length\n source.gsub(/^[ \\t]{#{indent}}/, '')\n end",
"def to_s\n codeCommentRatio = (sprintf \"%0.2f\", @code.to_f/@comments if @comments > 0) || '--'\n sprintf LINE_FORMAT, @code, @comments, @blank, @lines, codeCommentRatio, @name\n end",
"def format_source(source)\n source = source.chomp\n last = source.split(/\\r?\\n/).last\n indent = last ? last[/^([ \\t]*)/, 1].length : 0\n source.gsub(/^[ \\t]{#{indent}}/, '')\n end",
"def formatPreprocessor(theLines)\n\n\talignEndifs(\t\ttheLines);\n\talignUndefineDefine(theLines);\n\talignDefineValue(\ttheLines);\n\talignContinuations(\ttheLines);\n\n\treturn theLines;\n\nend",
"def my_name_is\n # and my code is here\n # two spaces for tabs in Ruby\nend",
"def format_code(text)\n simple_format( truncate( Sanitize.clean(markdown(text)).html_safe, escape: false, length: 299, separator: ' ', omission: ' …' ))\n end",
"def preformatting\n\n end",
"def build_verbatim margin\n verbatim = super\n\n verbatim.format = :ruby if @section == 'Examples'\n\n verbatim\n end",
"def formatGlobal(theLines)\n\n\talignAssignments(theLines);\n\nend",
"def formatScope(theScope, theLines)\n\n\tnewLines = theLines.dup;\n\t\n\tcase theScope\n\twhen :enum\n\t\tformatEnum(newLines);\n\t\n\twhen :struct\n\t\tformatStruct(newLines);\n\t\n\twhen :class\n\t\tformatClass(newLines);\n\t\n\twhen :constructor\n\t\tformatConstructor(newLines);\n\n\twhen :function\n\t\tformatFunction(newLines);\n\t\n\twhen :global\n\t\tformatGlobal(newLines);\n\tend\n\t\n\treturn newLines;\n\nend",
"def prettify(str); end",
"def make_my_diffs_pretty!; end",
"def inline_code; end",
"def format(text); end",
"def style_conversion; end",
"def format_source(value); end",
"def formatConstructor(theLines)\n\n\treplaceVoids(\t\ttheLines);\n\tspaceFirstComment(\ttheLines);\n\nend",
"def formatter=(_arg0); end",
"def formatter=(_arg0); end",
"def formatter=(_arg0); end",
"def format_arguments; end",
"def source_line; end",
"def code_snippet(source_file, source_line) #exception\n ##backtrace = exception.backtrace.reject{ |bt| bt =~ INTERNALS }\n ##backtrace.first =~ /(.+?):(\\d+(?=:|\\z))/ or return \"\"\n #caller =~ /(.+?):(\\d+(?=:|\\z))/ or return \"\"\n #source_file, source_line = $1, $2.to_i\n\n source = source(source_file)\n\n radius = 3 # number of surrounding lines to show\n region = [source_line - radius, 1].max ..\n [source_line + radius, source.length].min\n\n # ensure proper alignment by zero-padding line numbers\n format = \" %2s %0#{region.last.to_s.length}d %s\"\n\n pretty = region.map do |n|\n format % [('=>' if n == source_line), n, source[n-1].chomp]\n end #.unshift \"[#{region.inspect}] in #{source_file}\"\n\n pretty\n end",
"def normalize(code); end",
"def format_code\n 0\n end",
"def render(context)\n # Sanitize the code inside the block\n resolve_code = super.to_s.gsub(/\\A(\\n|\\r)+|(\\n|\\r)+\\z/, \"\")\n \n # Invoke Rouge to format our code\n formatted_code = rouge_resolve(resolve_code)\n \n # Output the formatted code with the proper HTML tags\n to_html_code(formatted_code)\n end",
"def base_description(_)\n if style == brace_alignment_style\n 'the position of the opening parenthesis'\n else\n 'the start of the line where the left parenthesis is'\n end\n end",
"def formatEnum(theLines)\n\n\talignAssignments(theLines);\n\nend",
"def process_code_listing(lines)\n # extract caption\n caption = nil\n # no caption for listings in appendix\n if !lines.first.index(\",\").nil?\n raise \"error [#{lines.first.index(\",\")}] [#{lines.first}]\" if lines.first.split(\",\").size != 2\n raise \"error\" if lines.first.split(\",\").first.split(\"=\").size != 2\n caption = lines.first.split(\",\").first.split(\"=\")[1] \n end\n # remove start and end\n lines = lines[1..-1]\n # pretty print \n return final_pretty_code_listing(lines, caption)\nend",
"def source_line=(_); end",
"def herebody_s; end",
"def as_you_like_it_quote; end",
"def _format_method\n return @_format_method if @_format_method\n\n arguments_type = ::Hash\n @_has_parameters = false\n\n # RANT RANT RANT:\n # THIS CODE DOES NOT WORK.\n # there is a bug in the Ruby parser in some cases.\n # In this object:\n # instance_eval(\"t :foo\")\n # cannot parse :foo\n # However it works fine in irb and ruby -e.\n #\n # [email protected] 2009/01/08\n=begin\n # Handle early subsititions.\n @_template = @template.gsub(/\\<\\{\\{(.*?)\\}\\}\\>/) do | m |\n expr = $1\n # expr = \"(#{expr}).to_s\"\n expr = \"\\n#{expr}\\n\"\n expr = \"begin#{expr}end\"\n #expr = \";nil; (#{expr});\"\n # expr = \"lambda { || #{expr}; }.call\"\n $stderr.puts \"expr = #{expr}\"\n #Contenter::Api::Selector.with(@_selector) do\n result = instance_eval(expr).to_s\n #end\n # $stderr.puts \"result = #{result.inspect}\"\n result\n end\n=end\n @_template ||= @template\n @_template = @template if @_template == @template\n @_template.freeze\n\n parameter_offset = -1\n p = @_template\n t = \"'\"\n until p.empty?\n case\n # Escape string delimiters.\n when m = /\\A([\\\\'])/.match(p)\n t << '\\\\' + m[1]\n\n # Parameter subsititutions.\n when m = /\\A(\\{\\{\\{(.*?)\\}\\}\\})/.match(p)\n t << '\\' << (' << m[2] << ').to_s << \\''\n @_has_parameters = true\n\n # \"early\" subsititutions.\n # SEE RANT ABOVE.\n when m = /\\A(\\<\\{\\{(.*?)\\}\\}\\>)/.match(p)\n t << '\\' << (' << m[2] << ').to_s << \\''\n @_has_parameters = true\n\n else\n t << p[0 .. 0]\n p = p[1 .. -1]\n \n end\n \n p = m.post_match if m\n end\n t << \"'\"\n\n # STDERR.puts \"template #{template.inspect} => #{t.inspect}\"\n\n # Decide on arguments defaults depending on the template substitutions.\n @arguments_default = \n case arguments_type\n when ::Array\n EMPTY_ARRAY\n when ::Hash\n EMPTY_HASH\n else\n EMPTY_HASH\n end\n @arguments = @arguments_default\n\n # $stderr.puts \"arguments = #{@arguments.inspect}\"\n # $stderr.puts \"arguments_default = #{@arguments_default.inspect}\"\n \n # Define a __format singleton method.\n # TODO: Not thread-safe.\n if @_has_parameters\n t = <<-\"END\"\n def self.__format(args)\n arguments_save = @arguments\n @arguments = args || @arguments_default\n #{t}\n ensure\n @arguments = arguments_save\n end\nEND\n else\n t = <<-\"END\"\n def self.__format(args)\n @_template\n end\nEND\n end\n\n # $stderr.puts \"@_format =\\n#{t}\"\n\n @_format_method = t.freeze\n\n rescue Exception => err\n new_err = err.class.new(\"#{err} in #{self.inspect}:\\n #{err.backtrace * \"\\n \"}\")\n raise new_err\n end",
"def format_compile_warning(file_name, file_path, reason,\n line, cursor); EMPTY; end",
"def parse_codespan; end",
"def fix_format_string(fmt)\n\t\t\tfmt.gsub(\"__\",\"%s\").gsub(\"_\",\"%s\")\n\tend",
"def myletter\n \n end",
"def inspect\n Thread.current[:formatador] ||= Formatador.new\n data = \"#{Thread.current[:formatador].indentation}<#{self.class.name}\"\n Thread.current[:formatador].indent do\n unless self.instance_variables.empty?\n vars = self.instance_variables.clone\n vars.delete(:@client)\n vars.delete(:@page)\n data << \" \"\n data << vars.map { |v| \"#{v}=#{instance_variable_get(v.to_s).inspect}\" }.join(\", \")\n end\n end\n data << \" >\"\n data\n end",
"def header_format; self.underline end",
"def process_code_state(ios, src, state)\n src.strip!\n src.gsub!(/^[ \\t]+/, '')\n case state\n when /code_(?:line_)?span/ then\n ios << \"\\n#{src}\"\n when /code_(?:line_)?print/ then\n ios << \"\\n_.((#{src}),ctx)\"\n when /code_(?:line_)?template/ then\n if src =~ /\\A(.*)(do|{)\\s*(\\|[^\\|]+\\|\\s*)?\\Z/\n ios << \"\\n(#{$~[1]}{#{$~[3]}\"\n @curly_end = $~[2] == '{'\n elsif !@curly_end && (src =~ /\\A\\s*end\\s*\\Z/)\n ios << '}).(_,ctx)'\n elsif @curly_end && (src =~ /\\A\\s*\\}\\s*\\Z/)\n ios << '}).(_,ctx)'\n else\n ios << \"\\n(#{src}).(_,ctx)\"\n end\n when /code_(?:line_)?visitor/\n m = src.match(/^([^ \\(]+)?(\\([^\\)]*\\))?\\s*(.*)$/)\n ios << \"\\n#{m[1]}_result=(#{m[3]}).(#{m[1]}_visitor#{m[2]},ctx)\"\n when :l10n then\n localize(ios, src)\n end\n end",
"def format!\n SimpleCov.formatter.new.format(self)\n end",
"def format!\n SimpleCov.formatter.new.format(self)\n end",
"def format!\n SimpleCov.formatter.new.format(self)\n end",
"def to_s\n lines = @lines.map(&:dup)\n\n if Pry.color\n lines.each do |l|\n l[0] = CodeRay.scan(l[0], @code_type).term\n end\n end\n\n if @with_line_numbers\n max_width = lines.last.last.to_s.length if lines.length > 0\n lines.each do |l|\n padded_line_num = l[1].to_s.rjust(max_width)\n l[0] = \"#{Pry::Helpers::BaseHelpers.colorize_code(padded_line_num.to_s)}: #{l[0]}\"\n end\n end\n\n if @with_marker\n lines.each do |l|\n if l[1] == @marker_line_num\n l[0] = \" => #{l[0]}\"\n else\n l[0] = \" #{l[0]}\"\n end\n end\n end\n\n if @with_indentation\n lines.each do |l|\n l[0] = \"#{' ' * @indentation_num}#{l[0]}\"\n end\n end\n\n lines.map { |l| \"#{l.first}\\n\" }.join\n end",
"def to_s\n \"#{indent(1)}def #{name}\\n\" <<\n \"#{indent(2)}# Code here later\\n\" <<\n \"#{indent(1)}end\"\n end",
"def indent_atom; \" \"; end",
"def basic_bug\n puts bug_line_1 = \" ----\\\\----/\".colorize(:green)\n puts bug_line_2 = \"/ \\/ @ @ \\\\\".colorize(:green)\n puts bug_line_3 = \"l====L\\__v__/\".colorize(:green)\nend",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def code; end",
"def optimize_indentation(value, amount = 0) # :doc:\n return \"#{value}\\n\" unless value.is_a?(String)\n\n if value.lines.size > 1\n value.strip_heredoc.indent(amount)\n else\n \"#{value.strip.indent(amount)}\\n\"\n end\n end",
"def to_s # {{{\n c = wrap( self.content.to_s.chomp )\n t = wrap( self.title.to_s.chomp )\n\n<<EOS\n|^\\___________________ [ #{self.source.to_s } ] _________________________________/^|\n\n\\t'#{t}'\n\n\\t#{c}\n\n|/^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\\|\n\nEOS\n end",
"def final_pretty_code_listing(lines, caption=nil, ruby_filename=nil)\n # remove trailining white space\n lines.each_with_index {|r,i| lines[i]=r.rstrip}\n # make a string\n raw = lines.join(\"\\r\\n\") # windows friendly?\n # pretty print does not like <> brackets\n raw = process_angle_brackets_and_ampersands(raw)\n s = \"\"\n add_line(s, \"<pre class='prettyprint'>#{raw}</pre>\")\n if !caption.nil?\n caption = post_process_text(caption) # process text\n add_line(s, \"<div class='caption'>#{caption}</div>\") \n end \n if !ruby_filename.nil?\n\t add_line(s, \"<div class='download_src'>Download: <a href='#{ruby_filename}'>#{ruby_filename}</a>. Unit test available in the <%=machinelearning_dev_url(\\\"github project\\\")%></div>\")\n\tend\n return s\nend",
"def build_details\n require \"wrong/rainbow\" if Wrong.config[:color]\n s = \"\"\n parts = self.parts\n parts.shift # remove the first part, since it's the same as the code\n\n details = []\n\n if parts.size > 0\n parts.each do |part|\n begin\n value = eval(part, block.binding)\n unless part == value.inspect # this skips literals or tautologies\n if part =~ /\\n/m\n part.gsub!(/\\n/, newline(2))\n part += newline(3)\n end\n value = pretty_value(value, (4 + part.length + 4))\n if Wrong.config[:color]\n part = part.color(:blue)\n value = value.color(:magenta)\n end\n details << indent(4, part, \" is \", value)\n end\n rescue Exception => e\n raises = \"raises #{e.class}\"\n if Wrong.config[:color]\n part = part.color(:blue)\n raises = raises.bold.color(:red)\n end\n formatted_exeption = if e.message and e.message != e.class.to_s\n indent(4, part, \" \", raises, \": \", indent_all(6, e.message))\n else\n indent(4, part, \" \", raises)\n end\n details << formatted_exeption\n end\n end\n end\n\n details.uniq!\n if details.empty?\n \"\"\n else\n \"\\n\" + details.join(\"\\n\") + \"\\n\"\n end\n\n end",
"def formation; end",
"def inline_formatting(str)\n str.rstrip!\n str = @re_help.rewrite_emphasis(str) do |marker, s|\n \"#{Tags[marker][:open]}#{s}#{Tags[marker][:close]}\"\n end\n str = @re_help.rewrite_images(str) do |link|\n \"<img src=\\\"#{link}\\\" />\"\n end\n str = @re_help.rewrite_links(str) do |link, text|\n text ||= link\n link = link.sub(/^file:(.*)::(.*?)$/) do\n\n # We don't support search links right now. Get rid of it.\n\n \"file:#{$1}\"\n end\n link = link.sub(/^file:/i, \"\") # will default to HTTP\n link = link.sub(/\\.org$/i, \".html\")\n \"<a href=\\\"#{link}\\\">#{text}</a>\"\n end\n if (@output_type == :table_row) then\n str.gsub!(/^\\|\\s*/, \"<td>\")\n str.gsub!(/\\s*\\|$/, \"</td>\")\n str.gsub!(/\\s*\\|\\s*/, \"</td><td>\")\n end\n if (@output_type == :table_header) then\n str.gsub!(/^\\|\\s*/, \"<th>\")\n str.gsub!(/\\s*\\|$/, \"</th>\")\n str.gsub!(/\\s*\\|\\s*/, \"</th><th>\")\n end\n str\n end",
"def inspect\n Thread.current[:formatador] ||= Formatador.new\n data = \"#{Thread.current[:formatador].indentation}<#{self.class.name}\"\n Thread.current[:formatador].indent do\n unless self.instance_variables.empty?\n vars = self.instance_variables.clone\n vars.delete(:@client)\n data << \" \"\n data << vars.map { |v| \"#{v}=#{instance_variable_get(v.to_s).inspect}\" }.join(\", \")\n end\n end\n data << \" >\"\n data\n end",
"def log_formatter; end",
"def log_formatter; end",
"def make_run_format!\n self.rut = Run.remove_format(self.rut)\n end"
] | [
"0.714464",
"0.714464",
"0.6775815",
"0.67662513",
"0.6688448",
"0.6566475",
"0.6558145",
"0.6558145",
"0.6544236",
"0.65372205",
"0.65372205",
"0.65372205",
"0.6506864",
"0.6506864",
"0.6506864",
"0.6506864",
"0.6506864",
"0.6506864",
"0.6506864",
"0.6506864",
"0.65035534",
"0.64850533",
"0.64452726",
"0.63531107",
"0.63144517",
"0.63144517",
"0.62950265",
"0.6275623",
"0.62571466",
"0.6237433",
"0.6237433",
"0.6144766",
"0.6144766",
"0.6144766",
"0.6144766",
"0.6144766",
"0.613687",
"0.6116214",
"0.60969836",
"0.6058672",
"0.6016768",
"0.6002024",
"0.5999674",
"0.5971125",
"0.5953735",
"0.5943406",
"0.5929498",
"0.5925421",
"0.58979684",
"0.58903754",
"0.58852655",
"0.58784556",
"0.587236",
"0.5865446",
"0.58437634",
"0.58437634",
"0.58437634",
"0.58422554",
"0.5839697",
"0.5837847",
"0.5827809",
"0.58129436",
"0.57909614",
"0.57744545",
"0.57362086",
"0.5726241",
"0.57011044",
"0.5690462",
"0.56898594",
"0.5685784",
"0.56842905",
"0.568375",
"0.56813574",
"0.56801045",
"0.56698024",
"0.56593513",
"0.5654899",
"0.56496125",
"0.56496125",
"0.56496125",
"0.5646035",
"0.5645455",
"0.5634663",
"0.5621512",
"0.56198674",
"0.56198674",
"0.56198674",
"0.56198674",
"0.56198674",
"0.56198674",
"0.56198674",
"0.5611027",
"0.56108254",
"0.560371",
"0.559942",
"0.5596684",
"0.5588904",
"0.55865866",
"0.5582624",
"0.5582624",
"0.5559515"
] | 0.0 | -1 |
GET /bar68s or /bar68s.json | def index
@bar68s = Bar68.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def view_api\n api_string = RestClient.get(\"https://itunes.apple.com/search?term=star+wars&entity=song&attribute=movieTerm\")\n api_hash = JSON.parse(api_string)\n\n end",
"def index\n base_url = 'https://www.googleapis.com/books/v1/volumes?q=fiction&maxResults=20'\n and_key = '&key='\n key = ENV['GOOGLE_BOOKS_API_KEY'] \n googleurl = base_url + and_key + key\n\n response = RestClient.get(googleurl)\n @books = JSON.parse(response)\n\n respond_to do |format|\n format.html\n format.json { render json: @books }\n end\n\nend",
"def show\n @barrack = Barrack.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @barrack }\n end\n end",
"def show\n @bar = Bar.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bar }\n end\n end",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\nend",
"def index\n @bar81s = Bar81.all\n end",
"def index\n @bar80s = Bar80.all\n end",
"def index\n @non_smoking_bars = NonSmokingBar.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @non_smoking_bars }\n end\n end",
"def serv_json\n \"http://api.dribbble.com/shots/popular?page=1\"\n end",
"def show\n @non_smoking_bar = NonSmokingBar.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @non_smoking_bar }\n end\n end",
"def index\n @gets = Get.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gets }\n end\n end",
"def index\n @bar76s = Bar76.all\n end",
"def index\n render json: {\n status: :success,\n urls: ShortUrl::top_100\n }\n end",
"def GET; end",
"def show\n render \"api/v1/bounties/show\"\n end",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n puts JSON.pretty_generate(result)\n result\nend",
"def get(path, params={})\n params = merge_set_up_params(params)\n @token = \"b3688c52-9235-45ca-b01f-c5b2b83a4f4f\"\n @result = Typhoeus::Request.get(API_URL + path, :params => params,\n :headers => {\"Authorization\" => \"Basic#{@token}\"})\n puts @result.body\n # check if the url looks correct in the log\n puts @result.effective_url\n # parse the result to json\n return JSON.parse(@result.body)\n end",
"def index\n url = \"https://data.cityofchicago.org/resource/x2n5-8w5q.json\"\n options = { :body => {:status => text}, :basic_auth => @auth }\n @response = HTTParty.get(url, options)\n\n @crime = Hash.new\n\n #@crime['block'] = @response[0]['block']\n @crime = @response\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gittos }\n end\n end",
"def get_response(resource, query_string)\n config = YAML.load(File.read(\"giantbomb.yaml\"))\n api_key = config['api_key']\n api_base = config['api_base']\n return HTTParty.get(\"#{api_base}/#{resource}/?api_key=#{api_key}&format=json&#{query_string}\")\nend",
"def list_all_shards(args = {}) \n get(\"/shards.json/\", args)\nend",
"def get; end",
"def get(path)\n request = Net::HTTP::Get.new @uri.path+'/'+path\n request.basic_auth @api_key, ''\n request['User-Agent'] = USER_AGENT\n response = @https.request request\n JSON.parse response.body\n end",
"def http( *args )\n p http_get( *args )\n end",
"def index\n @bar74s = Bar74.all\n end",
"def show\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @barrio }\n end\n end",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\n end",
"def get_json(path)\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n #puts \"🤖 GET #{path}\"\n #puts \"HTTP #{response.code}\"\n #puts JSON.pretty_generate(result)\n result\nend",
"def index\n @bar77s = Bar77.all\n end",
"def show\n @basin = Basin.find(params[:id])\n\n @client = YahooWeather::Client.new \n @response = @client.fetch_by_location('Massingir, Gaza, Mz','c')\n @reponse2 = @client.fetch_by_location('Louis Trichardt, Limpopo, South Africa','c')\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @basin }\n\n end\n end",
"def get(path)\n # TODO: do more hardening on the path\n if path.include?('covid19')\n request = Net::HTTP::Get.new(path, @headers)\n else\n request = Net::HTTP::Get.new('/v2' + path, @headers)\n end\n send_request(request)\n end",
"def request(args = {})\n response = @client.get(args[:url],\n argument_hash(args[:args] || {},\n args[:symbols] || []))\n JSON.parse(response.body)\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def index\n @bar82s = Bar82.all\n end",
"def get(path) # code generated from moviedb website\n url = URI(\"#{HOST_URL}#{path}#{ENV['API_KEY']}\")\n response = Net::HTTP.get_response(url)\n begin\n response_hash = JSON.parse(response.read_body)\n return response_hash\n rescue\n {}\n end\n end",
"def show\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @barrio }\n end\n end",
"def index\n @money = Money.all\n require 'net/http'\n require 'json'\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n @lookup_money = JSON.parse(@response)\n end",
"def foods_units\n get('/foods/units.json')\n end",
"def client_choose(offset = 10, limit = 20)\n response = Net::HTTP.get(\n URI(\"https://pokeapi.co/api/v2/pokemon/?offset=#{offset}&limit=#{limit}\")\n )\n \n JSON.parse(response)\nend",
"def dummy_api_hit\n # barchart daily data api hit return\n {\"status\":{\"code\":200,\"message\":\"Success.\"},\"results\":\n [{\"symbol\":\"AAPL\",\"exchange\":\"BATS\",\"name\":\"Apple Inc\",\"dayCode\":\"R\",\n \"serverTimestamp\":\"2018-12-28T13:32:27-06:00\",\"mode\":\"i\",\"lastPrice\":157.51,\n \"tradeTimestamp\":\"2018-12-28T14:17:24-06:00\",\"netChange\":1.36,\n \"percentChange\":0.87,\"unitCode\":\"2\",\"open\":157.3,\"high\":157.65,\n \"low\":154.55,\"close\":0,\"flag\":\"\",\"volume\":1949701\n }]\n }\n end",
"def drugbank_get(route, params)\n url = $drugbank_api + route\n res = HTTParty.get(url, :query => params, :headers => $drugbank_headers)\n return res\nend",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def show\n # Let's make sure someone is logged in. If not, send them to the user homepage\n if not session[:user_id] and not session[:bar_id]\n redirect_to '/userhome'\n return\n end\n \n # Fetch the bar being requested\n begin\n @bar = Bar.find(params[:id])\n rescue\n flash[:notice] = 'The requested bar does not exist.'\n redirect_to '/userhome'\n return\n end\n \n # Fetch the favorites \n @favorite = Favorite.where('user_id = ? and bar_id = ?', session[:user_id], @bar.id)\n \n # Fetch the events\n @events = BarEvent.where('bar_id = ?', @bar.id)\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @bar }\n end\n end",
"def show_page_api\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n # converts response to a Ruby hash \n @show_crypto = JSON.parse(@response)\n end",
"def index\n require 'rest-client'\n response = RestClient::Request.execute(method: :get, url: 'localhost:3001/colores',\n headers: {page: params[:page], items: 9})\n if response.code == 200\n body = JSON.parse(response.body)\n @colors = body[\"data\"]\n @page = body[\"page\"]\n end\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def index\n @bar42s = Bar42.all\n end",
"def make_request(search_term)\n JSON.parse(RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"))\nend",
"def index\n @bar22s = Bar22.all\n end",
"def index\n @user=current_user\n\t @bars = @user.bars\n\t bar_num = @user.bars.count\n\t logger.error \"Bar Num: #{bar_num}\"\n\t\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bars }\n\tend\n end",
"def index\n @bar71s = Bar71.all\n end",
"def list_active_aos_versions(args = {}) \n get(\"/aosversions.json/\", args)\nend",
"def index\n @bar8s = Bar8.all\n end",
"def get_brandings\n request :get, \"/v3/brandings.json\"\n end",
"def api_call(path:, query:)\n url = \"http://api.openweathermap.org#{path}\"\n query[:appid] = @api_key\n json = get_json(url: url, query: query)\n raise Error, 'Invalid API response' if json['cod'].blank?\n raise NotFound, json['message'] if json['cod'].to_i == 404\n raise Error, json['message'] if json['cod'].to_i != 200\n json\n end",
"def index\n @baz80s = Baz80.all\n end",
"def index\n @distros = getmydata(\"Distro\")\n pagination\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @distros }\n end\n end",
"def rest_get(url)\n JSON.parse(RestClient.get(url))\n end",
"def indexs\n\n\n #application/mixare-json \n\n \tslat = params[:slat]\n \tslon = params[:slon]\n \telat = params[:elat]\n \telon = params[:elon]\n\n \t# /hgt/_design/hgt/_view/tags?startkey=[-27,27]\\&endkey=[-25,28]\n #uri = \"#{DATABASE}/hgt/_design/hgt/_view/tags?startkey=[#{slat},#{slon}]&endkey=[#{elat},#{elon}]\"\n uri = \"#{DATABASE}/hgt/_design/hgt/_view/tags\"\n\n request = RestClient.get uri\n\n request = Yajl::Parser.parse(request)\n\n puts request.inspect\n\n response = {}\n response[:results] = []\n\n request[\"rows\"].each do |row|\n\n title = row[\"value\"][\"kind\"] == \"recommendation\" ? \"Go There - \" : \"Don't Go There - \"\n title = \"#{title}#{row['value']['description']}\"\n\n response[:results] << {\n id: row[\"id\"],\n lat: row[\"value\"][\"lat\"].to_s,\n lng: row[\"value\"][\"lon\"].to_s,\n elevation: \"0.0\",\n title: title,\n distance: \"1\",\n has_detail_page: \"0\",\n webpage: \"\"\n }\n end\n response[:status] = \"OK\"\n response[:num_results] = response[:results].length\n render json: response, :content_type => 'application/mixare-json'\n end",
"def search_for_google_books(search_term)\n url = \"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"\n response = RestClient.get(url)\n hash = JSON.parse(response)\n hash[\"items\"]\nend",
"def make_request(search_term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\")\n final_response = JSON.parse(response)\nend",
"def get(url); end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def index\n @bar47s = Bar47.all\n end",
"def index\n @foo88s = Foo88.all\n end",
"def get_json(state, city)\n HTTParty.get(\"http://api.wunderground.com/api/b0938627f87459c4/conditions/q/#{state}/#{city}.json\").parsed_response\nend",
"def get(route='', params = {}, filter = nil)\n url = base_url + route\n unless filter.nil?\n url << '/' + \"(#{ERB::Util.url_encode(filter)})\"\n end\n url << '.json'\n begin\n JSON.parse(RestClient.get(url, params: params))\n rescue RestClient::ResourceNotFound => e\n Object.new\n end\n end",
"def index\n @bar97s = Bar97.all\n end",
"def everything\n raw = JSON.parse(`curl -sX GET 'https://api.nirvanahq.com/?api=rest&appid=gem&authtoken=#{@token}&method=everything&since=0'`)\n raw['results']\n end",
"def index\n @urls = Url.get_top(25)\n # render json: @urls\n end",
"def api_get(path, params = {})\n api_request(:get, path, :params => params)\n end",
"def http_method\n :get\n end",
"def jacket_API_data\n if @style == 0 # Athletic\n #########################################\n # API call for Sweatshirts category.\n # Search with 'active' and 'hoodies' queries\n #########################################\n build_partial_url(\"&cat=girls-sweatshirts\", @jacket_size)\n\n @request_url += '&fts=active&fts=hoodies'\n\n sweatshirts_by_query_response = HTTParty.get(@request_url)\n\n sweatshirts_by_query_products = JSON.parse(sweatshirts_by_query_response.body)[\"products\"]\n\n jackets_products = sweatshirts_by_query_products\n\n elsif @style == 1 # Formal\n #########################################\n # API call for Sweaters category.\n # Search with 'cardigan' query\n #########################################\n build_partial_url(\"&cat=girls-sweaters\", @jacket_size)\n\n @request_url += '&fts=cardigan'\n\n sweaters_by_query_response = HTTParty.get(@request_url)\n\n sweaters_by_query_products = JSON.parse(sweaters_by_query_response.body)[\"products\"]\n\n jackets_products = sweaters_by_query_products\n\n elsif @style == 2 # Everyday\n #########################################\n # API call for Sweaters category.\n # Search with no query\n #########################################\n build_partial_url(\"&cat=girls-sweaters\", @jacket_size)\n\n sweaters_response = HTTParty.get(@request_url)\n\n sweaters_products = JSON.parse(sweaters_response.body)[\"products\"]\n\n #########################################\n # API call for Sweatshirts category.\n # Search with no query\n #########################################\n build_partial_url(\"&cat=girls-sweatshirts\", @jacket_size)\n\n sweatshirts_response = HTTParty.get(@request_url)\n\n sweatshirts_products = JSON.parse(sweatshirts_response.body)[\"products\"]\n\n #########################\n # Combine products\n #########################\n # Zip (interweave) products data into one array\n jackets_products = sweatshirts_products.zip(sweaters_products).flatten.compact\n\n elsif @style == 3 # Trendy\n #########################################\n # API call for Sweaters category.\n # Search with 'print' query\n #########################################\n build_partial_url(\"&cat=girls-sweaters\", @jacket_size)\n\n @request_url += '&fts=print'\n\n sweaters_by_query_response = HTTParty.get(@request_url)\n\n sweaters_by_query_products = JSON.parse(sweaters_by_query_response.body)[\"products\"]\n\n jackets_products = sweaters_by_query_products\n\n else\n puts \"ERROR. No style indicated\"\n end\n\n # Return an array of filtered products\n return jackets_products\n end",
"def bars_results\n # params = {\n # \"Beer Country\"=>[\"Hong Kong\"],\n # \"controller\"=>\"api/vendors\",\n # \"action\"=>\"bars_results\",\n # \"format\"=>\"json\"\n # }\n puts \">>>>>>>\"\n puts \"[#{params[\"Beer Country\"]}]\"\n puts \"[#{params[\"HK Location\"]}]\"\n puts \"[#{params[\"Beer Style\"]}]\"\n puts \"[#{params[\"Brewery Name\"]}]\"\n puts \"[#{params[\"Beer Name\"]}]\"\n puts \"<<<<<<<\"\n\n #@bars = Vendor.joins(:beers).where(\"beers.country = ? AND vendors.district = ? AND beers.simpstyle = ? AND beers.brewery = ? AND beers.name = ?\", params[\"Beer Country\"], params[\"HK Location\"], params[\"Beer Style\"], params[\"Brewery Name\"], params[\"Beer Name\"]).uniq\n\n search_terms = {}\n search_terms['beers.country'] = params[\"Beer Country\"] unless params[\"Beer Country\"].nil?\n search_terms['vendors.district'] = params[\"HK Location\"] unless params[\"HK Location\"].nil?\n search_terms['beers.simpstyle'] = params[\"Beer Style\"] unless params[\"Beer Style\"].nil?\n search_terms['beers.brewery'] = params[\"Brewery Name\"] unless params[\"Brewery Name\"].nil?\n search_terms['beers.name'] = params[\"Beer Name\"] unless params[\"Beer Name\"].nil?\n\n @user_id = current_user ? current_user.id : nil\n @bars = Vendor.joins(:beers).joins(:vendor_types).where(search_terms).where('vendor_types.vendor_type': 'Bar').uniq\n\n #@bars = Vendor.joins(:beers).where({\n # 'beers.country': params[\"Beer Country\"],\n # 'vendors.district': params[\"HK Location\"],\n # 'beers.simpstyle': params[\"Beer Style\"],\n # 'beers.brewery': params[\"Brewery Name\"],\n # 'beers.name': params[\"Beer Name\"]\n #}).uniq\n\n # @bars = Vendor.joins(:beers).where(\"beers.country = ? AND district = ?\", \"USA\", \"Sheung Wan\").uniq\n # @bars = VendorType.includes(:vendor).where(vendor_type: 'Bar').map(&:vendor) # returns just bars\n\n if @bars.nil?\n render json: { message: \"Cannot find bars\" }, status: :not_found\n else\n @bars\n end\n end",
"def room_descriptions_method\r\n my_port = 8081\r\n htttproomnumber = $roomnumber\r\n roomsNtext = \"/#{htttproomnumber}\"\r\n rooms_message = \"/rooms#{roomsNtext}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{rooms_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n return my_json[\"room\"].to_s\r\nend",
"def index\n @bar52s = Bar52.all\n end",
"def api_fetch(url)\n JSON.parse(RestClient.get url)\nend",
"def index\n @baz72s = Baz72.all\n end",
"def query_api(path)\n with_http_error_handling do\n res = RestClient.get(endpoint + path)\n h = Hash.from_xml(res.body)\n h[\"response\"]\n end\n end",
"def overview\n request_uri = \"#{@api_endpoint}/#{@key}\"\n HTTParty.get(request_uri)\n end",
"def overview\n request_uri = \"#{@api_endpoint}/#{@key}\"\n HTTParty.get(request_uri)\n end",
"def http_get(path, query, format = :json)\n uri = URI.parse(\"http://#{Jamendo::API_SERVER}/v#{Jamendo::API_VERSION}/#{path}#{query}\")\n puts uri.request_uri\n http = Net::HTTP.new(uri.host, uri.port) \n request = Net::HTTP::Get.new(uri.request_uri)\n begin\n response = http.request(request)\n result = parse_response(response)\n assert_response(result[:headers])\n return result[:results]\n rescue JamendoError => e\n e.inspect\n end\n end",
"def get\n raise NoMethodError unless is_full_route? @cur_route\n @retrieved_url = @cur_url\n response = HTTParty.get(\"https://api.uwaterloo.ca/v2#{@cur_url}.json\", { query: { key: @api_key, format: 'json' } })\n case response.code\n when 400...600\n raise \"UWaterloo API Server returned a #{response.code} error\"\n end\n @response = RecursiveOpenStruct.new response, recurse_over_arrays: true\n @meta = response['meta']\n @response.data\n end",
"def index\n @bar90s = Bar90.all\n end",
"def search\n @google = Rails.application.secrets.google_api_key\n puts query[\"query\"]\n @response = HTTParty.get(\"https://www.googleapis.com/books/v1/volumes?q=#{query[\"query\"]}&key=#{@google}\")\n render json: {data: @response}\n end",
"def film_api(url)\n film_response = RestClient.get(url)\n film_hash = JSON.parse(film_response)\nend",
"def index\n @baz81s = Baz81.all\n end",
"def show\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foo }\n end\n end",
"def do_GET(request, response)\n status = 200\n content_type = \"text/html\"\n body = \"bender version #{BENDER_VERSION}\"\n body += \"\\n\"\n\n response.status = status\n response['Content-Type'] = content_type\n response.body = body\n response.body = body\n end",
"def index\n # @bookings = Booking.all\n begin\n @response = Booking.get_bookings\n rescue RestClient::Exception => exception\n @error = exception.response\n end\n # binding.pry\n end",
"def _get\n http_method(:get)\n end",
"def test_read_all_info\n get '/v1/read_all?data=eyJOYW1lIjogIkVkdWFyZG8iLCAiQ291bnRyeSI6ICJCcmF6aWwiIH0%3D'\n assert last_response.ok?\n assert last_response.body.include?('Eduardo')\n assert last_response.body.include?('Brazil')\n end",
"def get(path, params={})\n params = merge_set_up_params(params)\n JSON.parse(Typhoeus::Request.get(API_URL + path, :params => params).body)[\"response\"]\n end",
"def get endpoint\n do_request :get, endpoint\n end",
"def all\n api_get(path)\n end",
"def index\n @bounties = Bounty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @bounties }\n end\n end",
"def test\n get(\"/help/test.json\")\n end",
"def test\n get(\"/help/test.json\")\n end"
] | [
"0.6062327",
"0.6025169",
"0.59530115",
"0.5924268",
"0.5870208",
"0.5806346",
"0.5778083",
"0.5746901",
"0.5712355",
"0.5683639",
"0.56712085",
"0.5658685",
"0.5645185",
"0.56428504",
"0.5616093",
"0.56131077",
"0.5599265",
"0.5566004",
"0.556595",
"0.5539394",
"0.5534587",
"0.55202013",
"0.5519201",
"0.551576",
"0.55137753",
"0.55131054",
"0.55116546",
"0.5510749",
"0.55089873",
"0.5505694",
"0.549546",
"0.54923785",
"0.5484006",
"0.5484006",
"0.54819924",
"0.5478052",
"0.547181",
"0.54543644",
"0.5439672",
"0.5438571",
"0.54364467",
"0.5435322",
"0.54208785",
"0.54140425",
"0.54094815",
"0.54026794",
"0.5401224",
"0.5401224",
"0.53976727",
"0.539385",
"0.5392297",
"0.53901196",
"0.5389137",
"0.5388578",
"0.53885204",
"0.5386267",
"0.53835",
"0.5374008",
"0.53606427",
"0.5356714",
"0.5356092",
"0.53520364",
"0.5350859",
"0.53502524",
"0.53457206",
"0.53434485",
"0.53361994",
"0.53291327",
"0.5328404",
"0.5326943",
"0.5325639",
"0.53238195",
"0.5322204",
"0.5321386",
"0.53197277",
"0.5308779",
"0.53046364",
"0.5303591",
"0.530187",
"0.5296081",
"0.5291718",
"0.52855",
"0.52855",
"0.5279514",
"0.52754945",
"0.5274619",
"0.52705634",
"0.5269794",
"0.5268604",
"0.526738",
"0.5266682",
"0.5263029",
"0.5261586",
"0.52610934",
"0.5260325",
"0.5258998",
"0.5255683",
"0.52502054",
"0.5247472",
"0.5247472"
] | 0.602136 | 2 |
GET /bar68s/1 or /bar68s/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n @barrack = Barrack.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @barrack }\n end\n end",
"def show\n @bar = Bar.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bar }\n end\n end",
"def view_api\n api_string = RestClient.get(\"https://itunes.apple.com/search?term=star+wars&entity=song&attribute=movieTerm\")\n api_hash = JSON.parse(api_string)\n\n end",
"def index\n base_url = 'https://www.googleapis.com/books/v1/volumes?q=fiction&maxResults=20'\n and_key = '&key='\n key = ENV['GOOGLE_BOOKS_API_KEY'] \n googleurl = base_url + and_key + key\n\n response = RestClient.get(googleurl)\n @books = JSON.parse(response)\n\n respond_to do |format|\n format.html\n format.json { render json: @books }\n end\n\nend",
"def index\n @bar68s = Bar68.all\n end",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\nend",
"def serv_json\n \"http://api.dribbble.com/shots/popular?page=1\"\n end",
"def show\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @barrio }\n end\n end",
"def get(path, params={})\n params = merge_set_up_params(params)\n @token = \"b3688c52-9235-45ca-b01f-c5b2b83a4f4f\"\n @result = Typhoeus::Request.get(API_URL + path, :params => params,\n :headers => {\"Authorization\" => \"Basic#{@token}\"})\n puts @result.body\n # check if the url looks correct in the log\n puts @result.effective_url\n # parse the result to json\n return JSON.parse(@result.body)\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n puts JSON.pretty_generate(result)\n result\nend",
"def get(path)\n # TODO: do more hardening on the path\n if path.include?('covid19')\n request = Net::HTTP::Get.new(path, @headers)\n else\n request = Net::HTTP::Get.new('/v2' + path, @headers)\n end\n send_request(request)\n end",
"def show\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @barrio }\n end\n end",
"def show\n @non_smoking_bar = NonSmokingBar.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @non_smoking_bar }\n end\n end",
"def show\n @basin = Basin.find(params[:id])\n\n @client = YahooWeather::Client.new \n @response = @client.fetch_by_location('Massingir, Gaza, Mz','c')\n @reponse2 = @client.fetch_by_location('Louis Trichardt, Limpopo, South Africa','c')\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @basin }\n\n end\n end",
"def show\n render \"api/v1/bounties/show\"\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get(path)\n request = Net::HTTP::Get.new @uri.path+'/'+path\n request.basic_auth @api_key, ''\n request['User-Agent'] = USER_AGENT\n response = @https.request request\n JSON.parse response.body\n end",
"def get_json(path)\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n #puts \"🤖 GET #{path}\"\n #puts \"HTTP #{response.code}\"\n #puts JSON.pretty_generate(result)\n result\nend",
"def index\n @bar81s = Bar81.all\n end",
"def get; end",
"def get_response(resource, query_string)\n config = YAML.load(File.read(\"giantbomb.yaml\"))\n api_key = config['api_key']\n api_base = config['api_base']\n return HTTParty.get(\"#{api_base}/#{resource}/?api_key=#{api_key}&format=json&#{query_string}\")\nend",
"def get(path) # code generated from moviedb website\n url = URI(\"#{HOST_URL}#{path}#{ENV['API_KEY']}\")\n response = Net::HTTP.get_response(url)\n begin\n response_hash = JSON.parse(response.read_body)\n return response_hash\n rescue\n {}\n end\n end",
"def index\n url = \"https://data.cityofchicago.org/resource/x2n5-8w5q.json\"\n options = { :body => {:status => text}, :basic_auth => @auth }\n @response = HTTParty.get(url, options)\n\n @crime = Hash.new\n\n #@crime['block'] = @response[0]['block']\n @crime = @response\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gittos }\n end\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def request(args = {})\n response = @client.get(args[:url],\n argument_hash(args[:args] || {},\n args[:symbols] || []))\n JSON.parse(response.body)\n end",
"def get_thing(query_hash)\n query = {\"type\" => \"/type/edition\"}.merge(query_hash)\n response = open(@api_url + \"/things?query=\" + CGI.escape(query.to_json) ).read\n JSON.parse(response)\n end",
"def http( *args )\n p http_get( *args )\n end",
"def index\n @gets = Get.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gets }\n end\n end",
"def room_descriptions_method\r\n my_port = 8081\r\n htttproomnumber = $roomnumber\r\n roomsNtext = \"/#{htttproomnumber}\"\r\n rooms_message = \"/rooms#{roomsNtext}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{rooms_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n return my_json[\"room\"].to_s\r\nend",
"def GET; end",
"def query_api(path)\n with_http_error_handling do\n res = RestClient.get(endpoint + path)\n h = Hash.from_xml(res.body)\n h[\"response\"]\n end\n end",
"def client_choose(offset = 10, limit = 20)\n response = Net::HTTP.get(\n URI(\"https://pokeapi.co/api/v2/pokemon/?offset=#{offset}&limit=#{limit}\")\n )\n \n JSON.parse(response)\nend",
"def get(path, params={})\n params = merge_set_up_params(params)\n JSON.parse(Typhoeus::Request.get(API_URL + path, :params => params).body)[\"response\"]\n end",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def get(id)\n _get(\"/quick-scan/#{id}\") { |json| json }\n end",
"def index\n @bar80s = Bar80.all\n end",
"def index\n @bar76s = Bar76.all\n end",
"def get_champion_data(patch_number)\n response_string = RestClient.get(\"http://ddragon.leagueoflegends.com/cdn/#{patch_number}/data/en_US/champion.json\")\n response_hash = JSON.parse(response_string)\n champion_data = response_hash[\"data\"]\nend",
"def get\n check_response( @httpcli.get(@endpoint) )\n end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def drugbank_get(route, params)\n url = $drugbank_api + route\n res = HTTParty.get(url, :query => params, :headers => $drugbank_headers)\n return res\nend",
"def show\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foo }\n end\n end",
"def api_get(path, params = {})\n api_request(:get, path, :params => params)\n end",
"def http_get(path, query, format = :json)\n uri = URI.parse(\"http://#{Jamendo::API_SERVER}/v#{Jamendo::API_VERSION}/#{path}#{query}\")\n puts uri.request_uri\n http = Net::HTTP.new(uri.host, uri.port) \n request = Net::HTTP::Get.new(uri.request_uri)\n begin\n response = http.request(request)\n result = parse_response(response)\n assert_response(result[:headers])\n return result[:results]\n rescue JamendoError => e\n e.inspect\n end\n end",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\n end",
"def index\n render json: {\n status: :success,\n urls: ShortUrl::top_100\n }\n end",
"def index\n @money = Money.all\n require 'net/http'\n require 'json'\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n @lookup_money = JSON.parse(@response)\n end",
"def list_active_aos_versions(args = {}) \n get(\"/aosversions.json/\", args)\nend",
"def get_batterie_by_building\n @battery = Battery.where(building_id: params[:building_id])\n respond_to do |format| \n format.json { render :json => @battery }\n end\n \n end",
"def index\n @bar74s = Bar74.all\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\" + id_param\n return response(url)\n end",
"def api_call(path:, query:)\n url = \"http://api.openweathermap.org#{path}\"\n query[:appid] = @api_key\n json = get_json(url: url, query: query)\n raise Error, 'Invalid API response' if json['cod'].blank?\n raise NotFound, json['message'] if json['cod'].to_i == 404\n raise Error, json['message'] if json['cod'].to_i != 200\n json\n end",
"def get(path, **args); end",
"def make_request(search_term)\n JSON.parse(RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"))\nend",
"def show\n # Let's make sure someone is logged in. If not, send them to the user homepage\n if not session[:user_id] and not session[:bar_id]\n redirect_to '/userhome'\n return\n end\n \n # Fetch the bar being requested\n begin\n @bar = Bar.find(params[:id])\n rescue\n flash[:notice] = 'The requested bar does not exist.'\n redirect_to '/userhome'\n return\n end\n \n # Fetch the favorites \n @favorite = Favorite.where('user_id = ? and bar_id = ?', session[:user_id], @bar.id)\n \n # Fetch the events\n @events = BarEvent.where('bar_id = ?', @bar.id)\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @bar }\n end\n end",
"def show\n client= Client.find_by_id params[:id]\n if client != nil\n render(json: client, status: 200) \n else\n head 404\n end \n end",
"def show\n @roof = Roof.find(params[:roof_id])\n @status = @roof.statuses.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @status }\n end\n end",
"def get(route='', params = {}, filter = nil)\n url = base_url + route\n unless filter.nil?\n url << '/' + \"(#{ERB::Util.url_encode(filter)})\"\n end\n url << '.json'\n begin\n JSON.parse(RestClient.get(url, params: params))\n rescue RestClient::ResourceNotFound => e\n Object.new\n end\n end",
"def api_fetch(url)\n JSON.parse(RestClient.get url)\nend",
"def food_info(food_id)\n get(\"/foods/#{food_id}.json\")\n end",
"def show_page_api\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n # converts response to a Ruby hash \n @show_crypto = JSON.parse(@response)\n end",
"def index\n @non_smoking_bars = NonSmokingBar.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @non_smoking_bars }\n end\n end",
"def dummy_api_hit\n # barchart daily data api hit return\n {\"status\":{\"code\":200,\"message\":\"Success.\"},\"results\":\n [{\"symbol\":\"AAPL\",\"exchange\":\"BATS\",\"name\":\"Apple Inc\",\"dayCode\":\"R\",\n \"serverTimestamp\":\"2018-12-28T13:32:27-06:00\",\"mode\":\"i\",\"lastPrice\":157.51,\n \"tradeTimestamp\":\"2018-12-28T14:17:24-06:00\",\"netChange\":1.36,\n \"percentChange\":0.87,\"unitCode\":\"2\",\"open\":157.3,\"high\":157.65,\n \"low\":154.55,\"close\":0,\"flag\":\"\",\"volume\":1949701\n }]\n }\n end",
"def index\n @bar77s = Bar77.all\n end",
"def find_single(scope) \n JSON[RestClient.get \"#{@site}/unit/#{scope}\", :accept=>'json'][0]\n end",
"def get endpoint\n do_request :get, endpoint\n end",
"def get\n start { |connection| connection.request http :Get }\n end",
"def get_monster_info\n monster_string = RestClient.get('http://www.dnd5eapi.co/api/monsters/')\n monster_hash = JSON.parse(monster_string)\n monster_info = monster_hash[\"results\"]\n monster_info\nend",
"def make_request(search_term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\")\n final_response = JSON.parse(response)\nend",
"def foods_units\n get('/foods/units.json')\n end",
"def rest_get(url)\n JSON.parse(RestClient.get(url))\n end",
"def get_item( item )\n @session.base_url = \"http://cl.ly\"\n resp = @session.get( \"/\" + item )\n \n raise ItemNotFound if resp.status == 404\n Crack::JSON.parse(resp.body)\n end",
"def get(path='/')\n `curl -sf http://localhost:3234#{path}`\n end",
"def get_json(state, city)\n HTTParty.get(\"http://api.wunderground.com/api/b0938627f87459c4/conditions/q/#{state}/#{city}.json\").parsed_response\nend",
"def index\n @bar71s = Bar71.all\n end",
"def getbatteries\n puts params\n buildid = params[\"buildingid\"]\n\n batteries = Battery.where(:building_id => buildid)\n\n puts batteries.inspect\n puts \"#################################################\"\n \n respond_to do |format|\n format.json { render json: batteries }\n end\n end",
"def search_for_google_books(search_term)\n url = \"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"\n response = RestClient.get(url)\n hash = JSON.parse(response)\n hash[\"items\"]\nend",
"def show\n @why_sumbar = WhySumbar.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @why_sumbar }\n end\n end",
"def get(path)\n request 'GET', path\n end",
"def pokemon_api_caller\nresponse = RestClient.get \"https://pokeapi.co/api/v2/pokemon/?offset=0&limit=807\"\nresponse_JSON = JSON.parse(response)\nresponse_JSON[\"results\"]\nend",
"def get(url); end",
"def list_all_shards(args = {}) \n get(\"/shards.json/\", args)\nend",
"def microservice_i(id)\r\n my_port = 8082\r\n store_message = \"/store/#{id}/#{$light}/#{$suit}/#{$wealth}/#{$sword}/#{$amulet}/#{$axe}/#{$food}/#{0}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{store_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n\r\n $light = my_json['light']\r\n $suit = my_json['suit']\r\n $wealth = my_json['wealth']\r\n $sword = my_json['sword']\r\n $amulet = my_json['amulet']\r\n $axe = my_json['axe']\r\n $food = my_json['food']\r\n puts(\"#{my_json['text']}\\n\")\r\n\r\n if id == 4\r\n food_units = gets.strip.to_i\r\n buy_food(7,food_units)\r\n end\r\nend",
"def index\n @distros = getmydata(\"Distro\")\n pagination\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @distros }\n end\n end",
"def show\n @battery_model = BatteryModel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @battery_model }\n end\n end",
"def show\n @api_haiku = Api::Haiku.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @api_haiku }\n end\n end",
"def http_method\n :get\n end",
"def json_get(path, params={})\n json_request(:get, path, params)\n end",
"def show\n @bloom = Bloom.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bloom }\n end\n end",
"def show\n @inventory_shelf_barcode = InventoryShelfBarcode.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @inventory_shelf_barcode }\n end\n end",
"def _get\n http_method(:get)\n end",
"def index\n @bar42s = Bar42.all\n end",
"def get\n raise NoMethodError unless is_full_route? @cur_route\n @retrieved_url = @cur_url\n response = HTTParty.get(\"https://api.uwaterloo.ca/v2#{@cur_url}.json\", { query: { key: @api_key, format: 'json' } })\n case response.code\n when 400...600\n raise \"UWaterloo API Server returned a #{response.code} error\"\n end\n @response = RecursiveOpenStruct.new response, recurse_over_arrays: true\n @meta = response['meta']\n @response.data\n end",
"def info\n get '/'\n end",
"def get(type, id)\n info = json_get(@target, \"#{type_info(type, :path)}/#{Addressable::URI.encode(id)}\",\n @key_style, headers)\n\n fake_client_id(info) if type == :client # hide client reply, not quite scim\n info\n end",
"def get_aos_version(args = {}) \n get(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend"
] | [
"0.62303185",
"0.61753106",
"0.60511845",
"0.5967835",
"0.5953472",
"0.59522194",
"0.5909464",
"0.5838846",
"0.58371335",
"0.5826596",
"0.58252764",
"0.5803539",
"0.5793828",
"0.5751416",
"0.5745294",
"0.57166857",
"0.57166857",
"0.57095236",
"0.56948847",
"0.5686634",
"0.5682059",
"0.56756866",
"0.56563896",
"0.56438965",
"0.56218314",
"0.56218314",
"0.5617114",
"0.56110734",
"0.5608671",
"0.55813074",
"0.5574813",
"0.5564549",
"0.5559889",
"0.5552906",
"0.55525047",
"0.5549677",
"0.5541923",
"0.55374897",
"0.55360734",
"0.5533221",
"0.55203396",
"0.5515858",
"0.55151856",
"0.5506341",
"0.5506276",
"0.54995257",
"0.54963684",
"0.54896885",
"0.54877424",
"0.54777217",
"0.54752046",
"0.5475175",
"0.5472652",
"0.5470342",
"0.5470342",
"0.54691",
"0.5465483",
"0.5463266",
"0.5457279",
"0.54483074",
"0.54448694",
"0.54445267",
"0.5443065",
"0.54418343",
"0.5439999",
"0.5439013",
"0.5438302",
"0.5437449",
"0.5434079",
"0.5433428",
"0.54327095",
"0.542531",
"0.54251605",
"0.54248905",
"0.54238915",
"0.54225093",
"0.5421425",
"0.5417471",
"0.5417207",
"0.5415626",
"0.5412896",
"0.54022443",
"0.53988767",
"0.5387598",
"0.53791755",
"0.53777045",
"0.5374989",
"0.5373929",
"0.5371308",
"0.5369507",
"0.53655416",
"0.5365343",
"0.5364792",
"0.5363375",
"0.5358938",
"0.5356298",
"0.5356231",
"0.5355529",
"0.5352924",
"0.53485453",
"0.5344316"
] | 0.0 | -1 |
POST /bar68s or /bar68s.json | def create
@bar68 = Bar68.new(bar68_params)
respond_to do |format|
if @bar68.save
format.html { redirect_to @bar68, notice: "Bar68 was successfully created." }
format.json { render :show, status: :created, location: @bar68 }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @bar68.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @bar80 = Bar80.new(bar80_params)\n\n respond_to do |format|\n if @bar80.save\n format.html { redirect_to @bar80, notice: \"Bar80 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar80 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar80.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar74 = Bar74.new(bar74_params)\n\n respond_to do |format|\n if @bar74.save\n format.html { redirect_to @bar74, notice: \"Bar74 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar74 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar74.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar8 = Bar8.new(bar8_params)\n\n respond_to do |format|\n if @bar8.save\n format.html { redirect_to @bar8, notice: \"Bar8 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar8 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar81 = Bar81.new(bar81_params)\n\n respond_to do |format|\n if @bar81.save\n format.html { redirect_to @bar81, notice: \"Bar81 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar81 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar76 = Bar76.new(bar76_params)\n\n respond_to do |format|\n if @bar76.save\n format.html { redirect_to @bar76, notice: \"Bar76 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar76 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar76.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar77 = Bar77.new(bar77_params)\n\n respond_to do |format|\n if @bar77.save\n format.html { redirect_to @bar77, notice: \"Bar77 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar77 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar77.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar71 = Bar71.new(bar71_params)\n\n respond_to do |format|\n if @bar71.save\n format.html { redirect_to @bar71, notice: \"Bar71 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar71 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar71.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar97 = Bar97.new(bar97_params)\n\n respond_to do |format|\n if @bar97.save\n format.html { redirect_to @bar97, notice: \"Bar97 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar97 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar97.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar84 = Bar84.new(bar84_params)\n\n respond_to do |format|\n if @bar84.save\n format.html { redirect_to @bar84, notice: \"Bar84 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar84 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar84.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar90 = Bar90.new(bar90_params)\n\n respond_to do |format|\n if @bar90.save\n format.html { redirect_to @bar90, notice: \"Bar90 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar90 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar90.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar52 = Bar52.new(bar52_params)\n\n respond_to do |format|\n if @bar52.save\n format.html { redirect_to @bar52, notice: \"Bar52 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar52 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar52.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar82 = Bar82.new(bar82_params)\n\n respond_to do |format|\n if @bar82.save\n format.html { redirect_to @bar82, notice: \"Bar82 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar82 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar82.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar42 = Bar42.new(bar42_params)\n\n respond_to do |format|\n if @bar42.save\n format.html { redirect_to @bar42, notice: \"Bar42 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar42 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar42.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @barrack = Barrack.new(params[:barrack])\n\n respond_to do |format|\n if @barrack.save\n format.html { redirect_to @barrack, notice: 'Barrack was successfully created.' }\n format.json { render json: @barrack, status: :created, location: @barrack }\n else\n format.html { render action: \"new\" }\n format.json { render json: @barrack.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar18 = Bar18.new(bar18_params)\n\n respond_to do |format|\n if @bar18.save\n format.html { redirect_to @bar18, notice: \"Bar18 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar18 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar18.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar50 = Bar50.new(bar50_params)\n\n respond_to do |format|\n if @bar50.save\n format.html { redirect_to @bar50, notice: \"Bar50 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar50 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar50.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar47 = Bar47.new(bar47_params)\n\n respond_to do |format|\n if @bar47.save\n format.html { redirect_to @bar47, notice: \"Bar47 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar47 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar47.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar34 = Bar34.new(bar34_params)\n\n respond_to do |format|\n if @bar34.save\n format.html { redirect_to @bar34, notice: \"Bar34 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar34 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar34.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar68_params\n params.require(:bar68).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @bar13 = Bar13.new(bar13_params)\n\n respond_to do |format|\n if @bar13.save\n format.html { redirect_to @bar13, notice: \"Bar13 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar13 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar13.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar22 = Bar22.new(bar22_params)\n\n respond_to do |format|\n if @bar22.save\n format.html { redirect_to @bar22, notice: \"Bar22 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar22 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar22.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo58 = Foo58.new(foo58_params)\n\n respond_to do |format|\n if @foo58.save\n format.html { redirect_to @foo58, notice: \"Foo58 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo58 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo58.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz80 = Baz80.new(baz80_params)\n\n respond_to do |format|\n if @baz80.save\n format.html { redirect_to @baz80, notice: \"Baz80 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz80 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz80.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar = Bar.new(bar_params)\n\n respond_to do |format|\n if @bar.save\n format.html { redirect_to @bar, notice: 'Bar was successfully created.' }\n format.json { render :show, status: :created, location: @bar }\n else\n format.html { render :new }\n format.json { render json: @bar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo56 = Foo56.new(foo56_params)\n\n respond_to do |format|\n if @foo56.save\n format.html { redirect_to @foo56, notice: \"Foo56 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo56 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo56.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo88 = Foo88.new(foo88_params)\n\n respond_to do |format|\n if @foo88.save\n format.html { redirect_to @foo88, notice: \"Foo88 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo88 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo88.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo83 = Foo83.new(foo83_params)\n\n respond_to do |format|\n if @foo83.save\n format.html { redirect_to @foo83, notice: \"Foo83 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo83 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @non_smoking_bar = NonSmokingBar.new(params[:non_smoking_bar])\n\n respond_to do |format|\n if @non_smoking_bar.save\n format.html { redirect_to root_url, notice: 'Successfully created.' }\n format.json { render json: @non_smoking_bar, status: :created, location: @non_smoking_bar }\n else\n format.html { render action: \"new\" }\n format.json { render json: @non_smoking_bar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo8 = Foo8.new(foo8_params)\n\n respond_to do |format|\n if @foo8.save\n format.html { redirect_to @foo8, notice: \"Foo8 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo8 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar36 = Bar36.new(bar36_params)\n\n respond_to do |format|\n if @bar36.save\n format.html { redirect_to @bar36, notice: \"Bar36 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar36 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar36.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz94 = Baz94.new(baz94_params)\n\n respond_to do |format|\n if @baz94.save\n format.html { redirect_to @baz94, notice: \"Baz94 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz94 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz94.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo97 = Foo97.new(foo97_params)\n\n respond_to do |format|\n if @foo97.save\n format.html { redirect_to @foo97, notice: \"Foo97 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo97 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo97.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar30 = Bar30.new(bar30_params)\n\n respond_to do |format|\n if @bar30.save\n format.html { redirect_to @bar30, notice: \"Bar30 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar30 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar30.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar80_params\n params.require(:bar80).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @foo81 = Foo81.new(foo81_params)\n\n respond_to do |format|\n if @foo81.save\n format.html { redirect_to @foo81, notice: \"Foo81 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo81 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo20 = Foo20.new(foo20_params)\n\n respond_to do |format|\n if @foo20.save\n format.html { redirect_to @foo20, notice: \"Foo20 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo20 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo20.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, json, params = {})\n if path.include?('covid19')\n request = Net::HTTP::Post.new(path, @headers)\n else\n request = Net::HTTP::Post.new('/v2' + path, @headers)\n end\n request.add_field('Content-Type', 'application/json')\n request.body = json\n params.each do |k, v|\n request[k] = v\n end\n send_request(request)\n end",
"def create\n @foo93 = Foo93.new(foo93_params)\n\n respond_to do |format|\n if @foo93.save\n format.html { redirect_to @foo93, notice: \"Foo93 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo93 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo93.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz81 = Baz81.new(baz81_params)\n\n respond_to do |format|\n if @baz81.save\n format.html { redirect_to @baz81, notice: \"Baz81 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz81 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo78 = Foo78.new(foo78_params)\n\n respond_to do |format|\n if @foo78.save\n format.html { redirect_to @foo78, notice: \"Foo78 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo78 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo78.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz83 = Baz83.new(baz83_params)\n\n respond_to do |format|\n if @baz83.save\n format.html { redirect_to @baz83, notice: \"Baz83 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz83 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo52 = Foo52.new(foo52_params)\n\n respond_to do |format|\n if @foo52.save\n format.html { redirect_to @foo52, notice: \"Foo52 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo52 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo52.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz69 = Baz69.new(baz69_params)\n\n respond_to do |format|\n if @baz69.save\n format.html { redirect_to @baz69, notice: \"Baz69 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz69 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz69.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo91 = Foo91.new(foo91_params)\n\n respond_to do |format|\n if @foo91.save\n format.html { redirect_to @foo91, notice: \"Foo91 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo91 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo91.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar64 = Bar64.new(bar64_params)\n\n respond_to do |format|\n if @bar64.save\n format.html { redirect_to @bar64, notice: \"Bar64 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar64 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar64.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar68.update(bar68_params)\n format.html { redirect_to @bar68, notice: \"Bar68 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar68 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar68.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo62 = Foo62.new(foo62_params)\n\n respond_to do |format|\n if @foo62.save\n format.html { redirect_to @foo62, notice: \"Foo62 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo62 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo62.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @barrack = Barrack.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @barrack }\n end\n end",
"def create\n @baz8 = Baz8.new(baz8_params)\n\n respond_to do |format|\n if @baz8.save\n format.html { redirect_to @baz8, notice: \"Baz8 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz8 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo19 = Foo19.new(foo19_params)\n\n respond_to do |format|\n if @foo19.save\n format.html { redirect_to @foo19, notice: \"Foo19 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo19 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo19.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz62 = Baz62.new(baz62_params)\n\n respond_to do |format|\n if @baz62.save\n format.html { redirect_to @baz62, notice: \"Baz62 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz62 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz62.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar81_params\n params.require(:bar81).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @foo98 = Foo98.new(foo98_params)\n\n respond_to do |format|\n if @foo98.save\n format.html { redirect_to @foo98, notice: \"Foo98 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo98 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo98.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bar_event = BarEvent.new\n @bar_event.bar_id = params[:bar_id]\n @bar_event.detail = params[:detail]\n \n #for header in request.env.select {|k,v| k.match(\"^HTTP.*\")}\n # print header\n #end\n #print \"Bar id: \" + request.env[\"HTTP_BAR_ID\"] + \"\\n\"\n #print \"Session id: \" + request.env[\"HTTP_SESSION_ID\"] + \"\\n\"\n #print \"Bar name: \" + request.env[\"HTTP_BAR_NAME\"] + \"\\n\"\n #print \"CSRF token: \" + request.env[\"HTTP_X_CSRF_TOKEN\"] + \"\\n\"\n \n # Get data and save to the bar_event object\n #print params.to_s\n\n respond_to do |format|\n if @bar_event.save\n #format.html { redirect_to @bar_event, :notice => 'Bar event was successfully created.' }\n format.html { render :text => @bar_event.id }\n format.json { render :json => @bar_event, :status => :created, :location => @bar_event }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @bar_event.errors, :status => :unprocessable_entity }\n end\n\tend\n end",
"def create\n @foo54 = Foo54.new(foo54_params)\n\n respond_to do |format|\n if @foo54.save\n format.html { redirect_to @foo54, notice: \"Foo54 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo54 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo54.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar82_params\n params.require(:bar82).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @foo38 = Foo38.new(foo38_params)\n\n respond_to do |format|\n if @foo38.save\n format.html { redirect_to @foo38, notice: \"Foo38 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo38 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo38.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz72 = Baz72.new(baz72_params)\n\n respond_to do |format|\n if @baz72.save\n format.html { redirect_to @baz72, notice: \"Baz72 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz72 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz72.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar80.update(bar80_params)\n format.html { redirect_to @bar80, notice: \"Bar80 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar80 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar80.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar97_params\n params.require(:bar97).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def test_post_sample_traces\n header 'Content-Type', 'application/json'\n\n (0..4).each do |i|\n data = File.read \"sample-traces/#{i}.json\"\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n assert last_response.ok?\n end\n end",
"def create\n @foo40 = Foo40.new(foo40_params)\n\n respond_to do |format|\n if @foo40.save\n format.html { redirect_to @foo40, notice: \"Foo40 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo40 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo40.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_post_then_get\n header 'Content-Type', 'application/json'\n\n data = File.read 'sample-traces/0.json'\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n id = last_response.body\n\n get \"/traces/#{id}\"\n check_valid_trace last_response.body\n end",
"def create\n @bar = Bar.new(params[:bar])\n\[email protected] = @bar.street_address + \", \" + @bar.city + \", \" + @bar.state + \", \" + @bar.zip_code\n\t@user = User.find(params[:os])\n\[email protected] = @user\n\[email protected]_id= @user.id\n respond_to do |format|\n if @bar.save\n format.html { redirect_to user_bar_path(@bar.user,@bar), notice: 'Bar was successfully created.' }\n format.json { render json: @bar, status: :created, location: @bar }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo71 = Foo71.new(foo71_params)\n\n respond_to do |format|\n if @foo71.save\n format.html { redirect_to @foo71, notice: \"Foo71 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo71 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo71.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, data = {})\n request 'POST', path, body: data.to_json\n end",
"def bar71_params\n params.require(:bar71).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @foo73 = Foo73.new(foo73_params)\n\n respond_to do |format|\n if @foo73.save\n format.html { redirect_to @foo73, notice: \"Foo73 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo73 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo73.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz66 = Baz66.new(baz66_params)\n\n respond_to do |format|\n if @baz66.save\n format.html { redirect_to @baz66, notice: \"Baz66 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz66 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz66.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar_params\n params.require(:bar).permit(:widget, :sprocket, :crank)\n end",
"def bar76_params\n params.require(:bar76).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def api_post(action, data, binary_key = nil)\n api_request(action, data, 'POST', binary_key)\n end",
"def bar90_params\n params.require(:bar90).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def post_spoonacular\n # %encode ingredients to url\n encoded_ingr = URI.escape(@translated_recipe[:ingredients_list])\n # post call block :\n url = URI(\"https://spoonacular-recipe-food-nutrition-v1.p.rapidapi.com/recipes/parseIngredients?includeNutrition=true\")\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Post.new(url)\n request[\"content-type\"] = \"application/x-www-form-urlencoded\"\n request[\"x-rapidapi-key\"] = ENV[\"X_RAPIDAPI_KEY\"]\n request[\"x-rapidapi-host\"] = \"spoonacular-recipe-food-nutrition-v1.p.rapidapi.com\"\n # body of the call with ingredients and servings\n request.body = \"ingredientList=#{encoded_ingr}&#{@recipe_hash[:servings]}\"\n # response\n response = http.request(request)\n end",
"def post operation, data={}\n body = case data\n when String\n body = data\n else\n Yajl::Encoder.encode(data)\n end\n\n request = new_request operation, body\n request.sign sts\n hydra.queue request\n hydra.run\n response = request.response\n puts response.inspect if @debug\n\n if response.code == 200\n Yajl::Parser.parse response.body\n else\n raise_error response\n end\n end",
"def http_post(path, request)\n @http.post(\n :body => JSON(:request => request.to_hash),\n :headers => headers,\n :path => \"/api/v2/#{path}\",\n :expects => [200, 201, 202]\n )\n end",
"def bar74_params\n params.require(:bar74).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @baz41 = Baz41.new(baz41_params)\n\n respond_to do |format|\n if @baz41.save\n format.html { redirect_to @baz41, notice: \"Baz41 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz41 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz41.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar_code_params\n params.require(:bar_code).permit(:asn, :part_code, :qty, :date, :lot_size, :target, :location)\n end",
"def create\n @baz27 = Baz27.new(baz27_params)\n\n respond_to do |format|\n if @baz27.save\n format.html { redirect_to @baz27, notice: \"Baz27 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz27 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz27.errors, status: :unprocessable_entity }\n end\n end\n end",
"def api_gateway_post(path, params)\n api_gateway_body_fwd = params.to_json\n rack_input = StringIO.new(api_gateway_body_fwd)\n\n post path, real_params = {}, {\"rack.input\" => rack_input}\nend",
"def create\n @bar4 = Bar4.new(bar4_params)\n\n respond_to do |format|\n if @bar4.save\n format.html { redirect_to @bar4, notice: \"Bar4 was successfully created.\" }\n format.json { render :show, status: :created, location: @bar4 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bar4.errors, status: :unprocessable_entity }\n end\n end\n end",
"def POST; end",
"def api_gateway_post(path, params)\n api_gateway_body_fwd = params.to_json\n rack_input = StringIO.new(api_gateway_body_fwd)\n\n post path, real_params = {}, 'rack.input' => rack_input\nend",
"def create\n @foo50 = Foo50.new(foo50_params)\n\n respond_to do |format|\n if @foo50.save\n format.html { redirect_to @foo50, notice: \"Foo50 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo50 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo50.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo77 = Foo77.new(foo77_params)\n\n respond_to do |format|\n if @foo77.save\n format.html { redirect_to @foo77, notice: \"Foo77 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo77 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo77.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baz54 = Baz54.new(baz54_params)\n\n respond_to do |format|\n if @baz54.save\n format.html { redirect_to @baz54, notice: \"Baz54 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz54 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz54.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar52_params\n params.require(:bar52).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @foo51 = Foo51.new(foo51_params)\n\n respond_to do |format|\n if @foo51.save\n format.html { redirect_to @foo51, notice: \"Foo51 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo51 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo51.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_json(path, body)\n uri = build_uri(path)\n puts \"*** POST #{path}\"\n puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n puts JSON.pretty_generate(result)\n result\nend",
"def create\n @barco = Barco.new(barco_params)\n\n respond_to do |format|\n if @barco.save\n format.html { redirect_to @barco, notice: 'Barco was successfully created.' }\n format.json { render action: 'show', status: :created, location: @barco }\n else\n format.html { render action: 'new' }\n format.json { render json: @barco.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_api(path, params={}, headers={})\n headers.merge!('CONTENT_TYPE' => \"application/json\")\n post path, params, headers\nend",
"def create\n @foo10 = Foo10.new(foo10_params)\n\n respond_to do |format|\n if @foo10.save\n format.html { redirect_to @foo10, notice: \"Foo10 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo10 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo10.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar77_params\n params.require(:bar77).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def bar47_params\n params.require(:bar47).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def create\n @bar_code = BarCode.new(bar_code_params)\n\n respond_to do |format|\n if @bar_code.save\n format.html { redirect_to @bar_code, notice: 'Bar code was successfully created.' }\n format.json { render :show, status: :created, location: @bar_code }\n else\n format.html { render :new }\n format.json { render json: @bar_code.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bar8_params\n params.require(:bar8).permit(:foo1, :foo2, :foo3, :foo4, :foo5)\n end",
"def test_post_invalid\n header 'Content-Type', 'application/json'\n\n json = JSON.generate [{ latitude: 'wrong', longitude: 'wrong' }]\n post('/traces', json, 'CONTENT_TYPE': 'application/json')\n\n contents = JSON.parse last_response.body\n assert_kind_of(Hash, contents, 'Response contents is not a hash')\n assert contents.key? 'description'\n assert(!last_response.ok?)\n end",
"def post_json(path, body)\n uri = build_uri(path)\n #puts \"🤖 POST #{path}\"\n #puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n #puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n #puts result[:result]\n result\nend",
"def create\n @baz55 = Baz55.new(baz55_params)\n\n respond_to do |format|\n if @baz55.save\n format.html { redirect_to @baz55, notice: \"Baz55 was successfully created.\" }\n format.json { render :show, status: :created, location: @baz55 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @baz55.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.6280484",
"0.61147785",
"0.6080365",
"0.60739577",
"0.6058968",
"0.60417044",
"0.6035992",
"0.6002331",
"0.596649",
"0.5910943",
"0.59073275",
"0.58393246",
"0.58381164",
"0.5814874",
"0.5796918",
"0.578256",
"0.5780741",
"0.57701945",
"0.5768486",
"0.5706695",
"0.5698048",
"0.56920135",
"0.5690161",
"0.56786853",
"0.5674361",
"0.5622326",
"0.5589139",
"0.557935",
"0.55663335",
"0.55492115",
"0.55437464",
"0.5542433",
"0.55392635",
"0.5530395",
"0.5521208",
"0.55198437",
"0.5519522",
"0.5516416",
"0.5506489",
"0.5488542",
"0.5472219",
"0.5470353",
"0.5448008",
"0.5442312",
"0.5429499",
"0.54152113",
"0.54074454",
"0.54069734",
"0.5402328",
"0.5399927",
"0.53982687",
"0.5398064",
"0.53901577",
"0.5384001",
"0.53805244",
"0.5372036",
"0.536861",
"0.5365109",
"0.5364495",
"0.536058",
"0.5358383",
"0.53516096",
"0.53328097",
"0.5331773",
"0.5314292",
"0.5310792",
"0.5310206",
"0.5308597",
"0.5308238",
"0.529936",
"0.5294431",
"0.52878565",
"0.52852404",
"0.5280987",
"0.52722013",
"0.5265752",
"0.52648664",
"0.5264258",
"0.5250761",
"0.52426004",
"0.5241544",
"0.523944",
"0.52392346",
"0.5237581",
"0.52228993",
"0.5221872",
"0.52209574",
"0.52132744",
"0.52130735",
"0.5207255",
"0.51969844",
"0.5192506",
"0.5187507",
"0.517569",
"0.51740396",
"0.51738745",
"0.51707715",
"0.5169964",
"0.5165517",
"0.51628107"
] | 0.64867765 | 0 |
PATCH/PUT /bar68s/1 or /bar68s/1.json | def update
respond_to do |format|
if @bar68.update(bar68_params)
format.html { redirect_to @bar68, notice: "Bar68 was successfully updated." }
format.json { render :show, status: :ok, location: @bar68 }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @bar68.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n respond_to do |format|\n if @bar77.update(bar77_params)\n format.html { redirect_to @bar77, notice: \"Bar77 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar77 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar77.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar74.update(bar74_params)\n format.html { redirect_to @bar74, notice: \"Bar74 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar74 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar74.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar80.update(bar80_params)\n format.html { redirect_to @bar80, notice: \"Bar80 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar80 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar80.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar42.update(bar42_params)\n format.html { redirect_to @bar42, notice: \"Bar42 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar42 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar42.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo83.update(foo83_params)\n format.html { redirect_to @foo83, notice: \"Foo83 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo83 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar71.update(bar71_params)\n format.html { redirect_to @bar71, notice: \"Bar71 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar71 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar71.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo8.update(foo8_params)\n format.html { redirect_to @foo8, notice: \"Foo8 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo8 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo88.update(foo88_params)\n format.html { redirect_to @foo88, notice: \"Foo88 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo88 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo88.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo56.update(foo56_params)\n format.html { redirect_to @foo56, notice: \"Foo56 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo56 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo56.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar8.update(bar8_params)\n format.html { redirect_to @bar8, notice: \"Bar8 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar8 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @barrack = Barrack.find(params[:id])\n\n respond_to do |format|\n if @barrack.update_attributes(params[:barrack])\n format.html { redirect_to @barrack, notice: 'Barrack was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @barrack.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar76.update(bar76_params)\n format.html { redirect_to @bar76, notice: \"Bar76 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar76 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar76.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar34.update(bar34_params)\n format.html { redirect_to @bar34, notice: \"Bar34 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar34 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar34.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo98.update(foo98_params)\n format.html { redirect_to @foo98, notice: \"Foo98 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo98 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo98.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo91.update(foo91_params)\n format.html { redirect_to @foo91, notice: \"Foo91 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo91 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo91.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo81.update(foo81_params)\n format.html { redirect_to @foo81, notice: \"Foo81 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo81 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar81.update(bar81_params)\n format.html { redirect_to @bar81, notice: \"Bar81 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar81 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo93.update(foo93_params)\n format.html { redirect_to @foo93, notice: \"Foo93 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo93 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo93.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar90.update(bar90_params)\n format.html { redirect_to @bar90, notice: \"Bar90 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar90 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar90.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar18.update(bar18_params)\n format.html { redirect_to @bar18, notice: \"Bar18 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar18 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar18.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo78.update(foo78_params)\n format.html { redirect_to @foo78, notice: \"Foo78 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo78 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo78.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar22.update(bar22_params)\n format.html { redirect_to @bar22, notice: \"Bar22 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar22 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar22.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo54.update(foo54_params)\n format.html { redirect_to @foo54, notice: \"Foo54 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo54 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo54.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo71.update(foo71_params)\n format.html { redirect_to @foo71, notice: \"Foo71 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo71 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo71.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar.update(bar_params)\n format.html { redirect_to @bar, notice: 'Bar was successfully updated.' }\n format.json { render :show, status: :ok, location: @bar }\n else\n format.html { render :edit }\n format.json { render json: @bar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo58.update(foo58_params)\n format.html { redirect_to @foo58, notice: \"Foo58 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo58 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo58.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo97.update(foo97_params)\n format.html { redirect_to @foo97, notice: \"Foo97 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo97 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo97.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo77.update(foo77_params)\n format.html { redirect_to @foo77, notice: \"Foo77 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo77 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo77.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo34.update(foo34_params)\n format.html { redirect_to @foo34, notice: \"Foo34 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo34 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo34.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar84.update(bar84_params)\n format.html { redirect_to @bar84, notice: \"Bar84 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar84 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar84.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo20.update(foo20_params)\n format.html { redirect_to @foo20, notice: \"Foo20 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo20 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo20.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo73.update(foo73_params)\n format.html { redirect_to @foo73, notice: \"Foo73 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo73 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo73.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo52.update(foo52_params)\n format.html { redirect_to @foo52, notice: \"Foo52 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo52 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo52.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo40.update(foo40_params)\n format.html { redirect_to @foo40, notice: \"Foo40 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo40 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo40.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo10.update(foo10_params)\n format.html { redirect_to @foo10, notice: \"Foo10 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo10 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo10.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar50.update(bar50_params)\n format.html { redirect_to @bar50, notice: \"Bar50 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar50 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar50.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo51.update(foo51_params)\n format.html { redirect_to @foo51, notice: \"Foo51 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo51 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo51.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar52.update(bar52_params)\n format.html { redirect_to @bar52, notice: \"Bar52 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar52 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar52.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo1.update(foo1_params)\n format.html { redirect_to @foo1, notice: \"Foo1 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo1 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo1.errors, status: :unprocessable_entity }\n end\n end\n end",
"def api_patch(path, data = {})\n api_request(:patch, path, :data => data)\n end",
"def update\n respond_to do |format|\n if @bar97.update(bar97_params)\n format.html { redirect_to @bar97, notice: \"Bar97 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar97 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar97.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo38.update(foo38_params)\n format.html { redirect_to @foo38, notice: \"Foo38 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo38 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo38.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz80.update(baz80_params)\n format.html { redirect_to @baz80, notice: \"Baz80 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz80 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz80.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar13.update(bar13_params)\n format.html { redirect_to @bar13, notice: \"Bar13 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar13 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar13.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @foobar = Foobar.find(params[:id])\n\n respond_to do |format|\n if @foobar.update_attributes(params[:foobar])\n format.html { redirect_to @foobar, notice: 'Foobar was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foobar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz41.update(baz41_params)\n format.html { redirect_to @baz41, notice: \"Baz41 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz41 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz41.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo50.update(foo50_params)\n format.html { redirect_to @foo50, notice: \"Foo50 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo50 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo50.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz72.update(baz72_params)\n format.html { redirect_to @baz72, notice: \"Baz72 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz72 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz72.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo62.update(foo62_params)\n format.html { redirect_to @foo62, notice: \"Foo62 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo62 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo62.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz81.update(baz81_params)\n format.html { redirect_to @baz81, notice: \"Baz81 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz81 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch\n headers = {\"If-Match\" => @version}\n response = @context.request :patch, \"#{@path}/#{@id}\", @data.to_json, headers\n @version += 1\n response\n # 'X-HTTP-Method-Override' => 'PATCH'\n end",
"def update\n respond_to do |format|\n if @baz8.update(baz8_params)\n format.html { redirect_to @baz8, notice: \"Baz8 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz8 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo63.update(foo63_params)\n format.html { redirect_to @foo63, notice: \"Foo63 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo63 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo63.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo32.update(foo32_params)\n format.html { redirect_to @foo32, notice: \"Foo32 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo32 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo32.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz83.update(baz83_params)\n format.html { redirect_to @baz83, notice: \"Baz83 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz83 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz42.update(baz42_params)\n format.html { redirect_to @baz42, notice: \"Baz42 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz42 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz42.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar36.update(bar36_params)\n format.html { redirect_to @bar36, notice: \"Bar36 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar36 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar36.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar30.update(bar30_params)\n format.html { redirect_to @bar30, notice: \"Bar30 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar30 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar30.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz55.update(baz55_params)\n format.html { redirect_to @baz55, notice: \"Baz55 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz55 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz55.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo37.update(foo37_params)\n format.html { redirect_to @foo37, notice: \"Foo37 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo37 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo37.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo19.update(foo19_params)\n format.html { redirect_to @foo19, notice: \"Foo19 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo19 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo19.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n if @foo.update_attributes(params[:foo])\n format.html { redirect_to @foo, notice: 'Foo was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo.update(foo_params)\n format.html { redirect_to @foo, notice: 'Foo was successfully updated.' }\n format.json { render :show, status: :ok, location: @foo }\n else\n format.html { render :edit }\n format.json { render json: @foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @my_foo.update(my_foo_params)\n format.html { redirect_to @my_foo, notice: 'My foo was successfully updated.' }\n format.json { render :show, status: :ok, location: @my_foo }\n else\n format.html { render :edit }\n format.json { render json: @my_foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz43.update(baz43_params)\n format.html { redirect_to @baz43, notice: \"Baz43 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz43 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz43.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update # PATCH\n raise NotImplementedError\n end",
"def update\n respond_to do |format|\n if @baz94.update(baz94_params)\n format.html { redirect_to @baz94, notice: \"Baz94 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz94 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz94.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(params)\n res = @client.put(path, nil, params, \"Content-Type\" => \"application/json\")\n @attributes = res.json if res.status == 201\n res\n end",
"def update\n respond_to do |format|\n if @foobar.update(foobar_params)\n format.html { redirect_to @foobar, notice: 'Foobar was successfully updated.' }\n format.json { render :show, status: :ok, location: @foobar }\n else\n format.html { render :edit }\n format.json { render json: @foobar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz69.update(baz69_params)\n format.html { redirect_to @baz69, notice: \"Baz69 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz69 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz69.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar47.update(bar47_params)\n format.html { redirect_to @bar47, notice: \"Bar47 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar47 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar47.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo7.update(foo7_params)\n format.html { redirect_to @foo7, notice: \"Foo7 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo7 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo7.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo13.update(foo13_params)\n format.html { redirect_to @foo13, notice: \"Foo13 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo13 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo13.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(url, data)\n RestClient.put url, data, :content_type => :json\nend",
"def update\n respond_to do |format|\n if @baz23.update(baz23_params)\n format.html { redirect_to @baz23, notice: \"Baz23 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz23 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz23.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo11.update(foo11_params)\n format.html { redirect_to @foo11, notice: \"Foo11 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo11 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo11.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz35.update(baz35_params)\n format.html { redirect_to @baz35, notice: \"Baz35 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz35 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz35.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @barco.update(barco_params)\n format.html { redirect_to @barco, notice: 'Barco was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @barco.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, data)\n request 'PATCH', path, body: data.to_json\n end",
"def update\n respond_to do |format|\n if @baz66.update(baz66_params)\n format.html { redirect_to @baz66, notice: \"Baz66 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz66 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz66.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar82.update(bar82_params)\n format.html { redirect_to @bar82, notice: \"Bar82 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar82 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar82.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar.update(bar_params)\n format.html { redirect_to @bar, notice: 'Bar was successfully updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n if @barrio.update_attributes(params[:barrio])\n format.html { redirect_to @barrio, notice: 'Barrio was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @barrio.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz54.update(baz54_params)\n format.html { redirect_to @baz54, notice: \"Baz54 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz54 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz54.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz62.update(baz62_params)\n format.html { redirect_to @baz62, notice: \"Baz62 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz62 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz62.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(&block)\n validate_request()\n\n # Params includes all of the PATCH data at the top level along with other\n # other Rails-injected params like 'id', 'action', 'controller'. These\n # are harmless given no namespace collision and we're only interested in\n # the 'Operations' key for the actual patch data.\n #\n render(json: yield(self.safe_params()[:id], self.safe_params().to_hash()))\n end",
"def update\n respond_to do |format|\n if @baz27.update(baz27_params)\n format.html { redirect_to @baz27, notice: \"Baz27 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz27 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz27.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz1.update(baz1_params)\n format.html { redirect_to @baz1, notice: \"Baz1 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz1 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz1.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baristum.update(baristum_params)\n format.html { redirect_to @baristum, notice: 'Baristum was successfully updated.' }\n format.json { render :show, status: :ok, location: @baristum }\n else\n format.html { render :edit }\n format.json { render json: @baristum.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(type, info)\n path, info = type_info(type, :path), force_case(info)\n ida = type == :client ? 'client_id' : 'id'\n raise ArgumentError, \"info must include #{ida}\" unless id = info[ida]\n hdrs = headers\n if info && info['meta'] && (etag = info['meta']['version'])\n hdrs.merge!('if-match' => etag)\n end\n reply = json_parse_reply(@key_style,\n *json_patch(@target, \"#{path}/#{Addressable::URI.encode(id)}\", info, hdrs))\n\n # hide client endpoints that are not quite scim compatible\n type == :client && !reply ? get(type, info['client_id']): reply\n end",
"def update\n respond_to do |format|\n if @foo2.update(foo2_params)\n format.html { redirect_to @foo2, notice: \"Foo2 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo2 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo2.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar_item.update(bar_item_params)\n format.html { redirect_to @bar_item, notice: 'Bar item was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @bar_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz44.update(baz44_params)\n format.html { redirect_to @baz44, notice: \"Baz44 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz44 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz44.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bar4.update(bar4_params)\n format.html { redirect_to @bar4, notice: \"Bar4 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @bar4 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @bar4.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @non_smoking_bar = NonSmokingBar.find(params[:id])\n\n respond_to do |format|\n if @non_smoking_bar.update_attributes(params[:non_smoking_bar])\n format.html { redirect_to root_url, notice: 'Successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @non_smoking_bar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @baz32.update(baz32_params)\n format.html { redirect_to @baz32, notice: \"Baz32 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @baz32 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @baz32.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch!\n request! :patch\n end",
"def update\n @barrio = Barrio.find(params[:id])\n\n respond_to do |format|\n if @barrio.update_attributes(params[:barrio])\n format.html { redirect_to @barrio, :notice => 'Barrio ha sido actualizado.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @barrio.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update(resource,identifier,json)\n raise 'Not Yet Implemented'\n end",
"def update_tenant_circle(args = {}) \n put(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend"
] | [
"0.6718046",
"0.6685876",
"0.66405016",
"0.6616602",
"0.66161853",
"0.6613844",
"0.661159",
"0.66055024",
"0.6593854",
"0.6579685",
"0.6569437",
"0.6564225",
"0.6558422",
"0.65565634",
"0.6550364",
"0.65436465",
"0.6540005",
"0.65352577",
"0.6527858",
"0.6489772",
"0.647327",
"0.64564174",
"0.64545894",
"0.6445496",
"0.64397496",
"0.64369345",
"0.6431082",
"0.6421178",
"0.6417293",
"0.64049375",
"0.64004475",
"0.639541",
"0.6394631",
"0.63684785",
"0.6362519",
"0.63451564",
"0.6337411",
"0.63221234",
"0.63213813",
"0.63209784",
"0.6320564",
"0.6319446",
"0.63058513",
"0.6304958",
"0.63046294",
"0.63006264",
"0.62999046",
"0.62973475",
"0.6285139",
"0.62638754",
"0.6255876",
"0.6240693",
"0.6237865",
"0.6236393",
"0.6232652",
"0.6221574",
"0.62190765",
"0.619949",
"0.6196451",
"0.6188863",
"0.6186824",
"0.61835593",
"0.6171289",
"0.6161755",
"0.6154181",
"0.61514133",
"0.61505437",
"0.61479694",
"0.614789",
"0.6143616",
"0.61406404",
"0.61369944",
"0.6134276",
"0.61298895",
"0.61293244",
"0.6127629",
"0.61234045",
"0.61198497",
"0.6109184",
"0.60804844",
"0.6070038",
"0.6054348",
"0.60477686",
"0.6032276",
"0.60296667",
"0.6013498",
"0.6007298",
"0.6005163",
"0.5991623",
"0.59779525",
"0.59776956",
"0.59662783",
"0.5949292",
"0.59425986",
"0.59143203",
"0.5911503",
"0.5891803",
"0.5883772",
"0.58679473",
"0.58673453"
] | 0.6740213 | 0 |
DELETE /bar68s/1 or /bar68s/1.json | def destroy
@bar68.destroy
respond_to do |format|
format.html { redirect_to bar68s_url, notice: "Bar68 was successfully destroyed." }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def delete_json(path)\n url = [base_url, path].join\n resp = HTTParty.delete(url, headers: standard_headers)\n parse_json(url, resp)\n end",
"def cmd_delete argv\n setup argv\n uuid = @hash['uuid']\n response = @api.delete(uuid)\n msg response\n return response\n end",
"def test_del\n header 'Content-Type', 'application/json'\n\n data = File.read 'sample-traces/0.json'\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n\n id = last_response.body\n\n delete \"/traces/#{id}\"\n assert last_response.ok?\n\n get \"/traces/#{id}\"\n\n contents = JSON.parse last_response.body\n assert_kind_of(Hash, contents, 'Response contents is not a hash')\n assert contents.key? 'description'\n assert(!last_response.ok?)\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def api_delete(path, data = {})\n api_request(:delete, path, :data => data)\n end",
"def delete path\n make_request(path, \"delete\", {})\n end",
"def delete(*rest) end",
"def delete(path)\n repository = path.split(/\\//)[2]\n objectid = path.split(/\\//)[3]\n if storage_fetch(repository, objectid) && storage_delete(repository, objectid)\n ['200', {}, []]\n else\n ['404', {}, [\"Repository #{repository} or ObjectID #{objectid} not found: #{path}\"]]\n end\n end",
"def destroy\n @bar74.destroy\n respond_to do |format|\n format.html { redirect_to bar74s_url, notice: \"Bar74 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def destroy\n @baz72.destroy\n respond_to do |format|\n format.html { redirect_to baz72s_url, notice: \"Baz72 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar71.destroy\n respond_to do |format|\n format.html { redirect_to bar71s_url, notice: \"Bar71 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path)\n RestClient.delete request_base+path\n end",
"def delete(command)\n pp @client.files.delete(clean_up(command[1]))\n end",
"def delete!( opts = {} )\n http_action :delete, nil, opts\n end",
"def delete(major,minor)\n major = major.to_sym\n if minor\n delete_hash = minor\n else\n if storage.hash_exists?(major)\n delete_hash = storage.find(major)\n else\n puts 'Delete hash not found in storage.'\n puts 'Use: imgurr delete <id> <delete_hash>'\n return\n end\n end\n if ImgurAPI.delete(delete_hash)\n puts 'Successfully deleted image from Imgur'\n storage.delete(major)\n storage.save\n else\n puts 'Unauthorized Access. Wrong delete hash?'\n end\n end",
"def delete\n response = WebPay.client.delete(path)\n response['deleted']\n end",
"def destroy\n @bar77.destroy\n respond_to do |format|\n format.html { redirect_to bar77s_url, notice: \"Bar77 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo71.destroy\n respond_to do |format|\n format.html { redirect_to foo71s_url, notice: \"Foo71 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n res = HTTParty.get URL, headers: HEADERS\n message = JSON.parse res.body, symbolize_names: true\n if res.code == 200\n numSubs = message[:data].count\n if numSubs > 0\n message[:data].each do |sub|\n id = sub[:id]\n delRes = HTTParty.delete \"#{URL}/#{id}\", headers: HEADERS\n #TODO handle status codes\n end\n end\n end\n end",
"def destroy\n @foo54.destroy\n respond_to do |format|\n format.html { redirect_to foo54s_url, notice: \"Foo54 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo83.destroy\n respond_to do |format|\n format.html { redirect_to foo83s_url, notice: \"Foo83 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar84.destroy\n respond_to do |format|\n format.html { redirect_to bar84s_url, notice: \"Bar84 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo97.destroy\n respond_to do |format|\n format.html { redirect_to foo97s_url, notice: \"Foo97 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo52.destroy\n respond_to do |format|\n format.html { redirect_to foo52s_url, notice: \"Foo52 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo56.destroy\n respond_to do |format|\n format.html { redirect_to foo56s_url, notice: \"Foo56 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar34.destroy\n respond_to do |format|\n format.html { redirect_to bar34s_url, notice: \"Bar34 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar97.destroy\n respond_to do |format|\n format.html { redirect_to bar97s_url, notice: \"Bar97 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar90.destroy\n respond_to do |format|\n format.html { redirect_to bar90s_url, notice: \"Bar90 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar80.destroy\n respond_to do |format|\n format.html { redirect_to bar80s_url, notice: \"Bar80 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar47.destroy\n respond_to do |format|\n format.html { redirect_to bar47s_url, notice: \"Bar47 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n client.delete(url)\n @deleted = true\nend",
"def http_delete(path, data = nil, content_type = 'application/json')\n http_methods(path, :delete, data, content_type)\n end",
"def destroy\n @foo93.destroy\n respond_to do |format|\n format.html { redirect_to foo93s_url, notice: \"Foo93 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo63.destroy\n respond_to do |format|\n format.html { redirect_to foo63s_url, notice: \"Foo63 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar76.destroy\n respond_to do |format|\n format.html { redirect_to bar76s_url, notice: \"Bar76 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo73.destroy\n respond_to do |format|\n format.html { redirect_to foo73s_url, notice: \"Foo73 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path, params)\n headers = {:Authorization => \"token #{token}\", :content_type => :json, :accept => :json}\n res = RestClient.delete(\"#{github_api_uri}/#{path}\", params.to_json, headers)\n Yajl.load(res)\n end",
"def do_delete(uri = \"\")\n @connection.delete do |req|\n req.url uri\n req.headers['Content-Type'] = 'application/json'\n end\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def destroy\n @foo62.destroy\n respond_to do |format|\n format.html { redirect_to foo62s_url, notice: \"Foo62 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar52.destroy\n respond_to do |format|\n format.html { redirect_to bar52s_url, notice: \"Bar52 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz41.destroy\n respond_to do |format|\n format.html { redirect_to baz41s_url, notice: \"Baz41 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo51.destroy\n respond_to do |format|\n format.html { redirect_to foo51s_url, notice: \"Foo51 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo81.destroy\n respond_to do |format|\n format.html { redirect_to foo81s_url, notice: \"Foo81 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def test_delete_preconditions_failed\n request = Http::Request.new(\n 'DELETE',\n '/file1',\n 'If-Match' => \"\\\"#{Digest::MD5.hexdigest('bar')}\\\"\"\n )\n\n response = self.request(request)\n\n assert_equal(\n 412,\n response.status,\n \"Incorrect status code. Response body: #{response.body_as_string}\"\n )\n end",
"def destroy\n @foo91.destroy\n respond_to do |format|\n format.html { redirect_to foo91s_url, notice: \"Foo91 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar81.destroy\n respond_to do |format|\n format.html { redirect_to bar81s_url, notice: \"Bar81 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar18.destroy\n respond_to do |format|\n format.html { redirect_to bar18s_url, notice: \"Bar18 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n url = prefix + \"delete\" + id_param\n return response(url)\n end",
"def destroy\n @baz94.destroy\n respond_to do |format|\n format.html { redirect_to baz94s_url, notice: \"Baz94 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def deletef\n url = prefix + \"deletef\" + id_param\n return response(url)\n end",
"def destroy\n @foo58.destroy\n respond_to do |format|\n format.html { redirect_to foo58s_url, notice: \"Foo58 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar42.destroy\n respond_to do |format|\n format.html { redirect_to bar42s_url, notice: \"Bar42 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar64.destroy\n respond_to do |format|\n format.html { redirect_to bar64s_url, notice: \"Bar64 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo64.destroy\n respond_to do |format|\n format.html { redirect_to foo64s_url, notice: \"Foo64 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz62.destroy\n respond_to do |format|\n format.html { redirect_to baz62s_url, notice: \"Baz62 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz55.destroy\n respond_to do |format|\n format.html { redirect_to baz55s_url, notice: \"Baz55 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo78.destroy\n respond_to do |format|\n format.html { redirect_to foo78s_url, notice: \"Foo78 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete(path)\n path = relativize_path path\n\n Precog.connect self do |http|\n uri = Addressable::URI.new\n uri.query_values = { :apiKey => api_key }\n\n http.delete \"/ingest/v#{VERSION}/fs/#{path}?#{uri.query}\"\n end\n end",
"def delete(resource)\n headers = base_headers.merge('Content-Type' => 'application/json')\n url = \"#{@base_url}/#{resource}\"\n\n @logger.debug(\"DELETE request Url: #{url}\")\n @logger.debug(\"-- Headers: #{headers}\")\n\n x = HTTParty.delete(url, headers: headers)\n puts x.inspect\n x\n end",
"def destroy\n @baz83.destroy\n respond_to do |format|\n format.html { redirect_to baz83s_url, notice: \"Baz83 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo34.destroy\n respond_to do |format|\n format.html { redirect_to foo34s_url, notice: \"Foo34 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar36.destroy\n respond_to do |format|\n format.html { redirect_to bar36s_url, notice: \"Bar36 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar8.destroy\n respond_to do |format|\n format.html { redirect_to bar8s_url, notice: \"Bar8 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz54.destroy\n respond_to do |format|\n format.html { redirect_to baz54s_url, notice: \"Baz54 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def orchio_delete\n response = client.send_request :delete, inst_args\n orchio_status response, 204\n end",
"def b2_delete_file(file)\n\n if parse_files_json(file) == {}\n\n puts \"File not present\"\n\n else\n \n result_hash = convert_json(b2_delete_file_version(file))\n\n if result_hash[\"fileName\"] == file\n puts \"File deleted successfully\"\n else\n puts \"Error deleting file\"\n end\n\n end\n\nend",
"def destroy\n @baz69.destroy\n respond_to do |format|\n format.html { redirect_to baz69s_url, notice: \"Baz69 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo98.destroy\n respond_to do |format|\n format.html { redirect_to foo98s_url, notice: \"Foo98 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz43.destroy\n respond_to do |format|\n format.html { redirect_to baz43s_url, notice: \"Baz43 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo77.destroy\n respond_to do |format|\n format.html { redirect_to foo77s_url, notice: \"Foo77 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n execute_request('DELETE') do |uri, headers|\n HTTP.http_client.delete(uri, header: headers)\n end\n end",
"def destroy\n @foobar = Foobar.find(params[:id])\n @foobar.destroy\n\n respond_to do |format|\n format.html { redirect_to foobars_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar13.destroy\n respond_to do |format|\n format.html { redirect_to bar13s_url, notice: \"Bar13 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz80.destroy\n respond_to do |format|\n format.html { redirect_to baz80s_url, notice: \"Baz80 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz81.destroy\n respond_to do |format|\n format.html { redirect_to baz81s_url, notice: \"Baz81 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar22.destroy\n respond_to do |format|\n format.html { redirect_to bar22s_url, notice: \"Bar22 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo = Foo.find(params[:id])\n @foo.destroy\n\n respond_to do |format|\n format.html { redirect_to foos_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @foo88.destroy\n respond_to do |format|\n format.html { redirect_to foo88s_url, notice: \"Foo88 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete_data\n response = WebPay.client.delete([path, 'data'].join('/'))\n response['deleted']\n end",
"def destroy\n @ruby.destroy\n respond_to do |format|\n format.html { redirect_to rubies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz35.destroy\n respond_to do |format|\n format.html { redirect_to baz35s_url, notice: \"Baz35 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @barrack = Barrack.find(params[:id])\n @barrack.destroy\n\n respond_to do |format|\n format.html { redirect_to barracks_url }\n format.json { head :no_content }\n end\n end",
"def delete(*args)\n request(:delete, *args)\n end",
"def delete\n request(:delete)\n end",
"def delete(name); end",
"def delete(name); end",
"def delete!(*rest) end",
"def destroy\n @foo32.destroy\n respond_to do |format|\n format.html { redirect_to foo32s_url, notice: \"Foo32 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo38.destroy\n respond_to do |format|\n format.html { redirect_to foo38s_url, notice: \"Foo38 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @baz8.destroy\n respond_to do |format|\n format.html { redirect_to baz8s_url, notice: \"Baz8 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bar50.destroy\n respond_to do |format|\n format.html { redirect_to bar50s_url, notice: \"Bar50 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end"
] | [
"0.67019",
"0.6633845",
"0.6626538",
"0.6600448",
"0.65777886",
"0.65484816",
"0.65409064",
"0.65267766",
"0.6513855",
"0.6470938",
"0.64658636",
"0.64658636",
"0.6462062",
"0.64619285",
"0.64557457",
"0.6436844",
"0.6406543",
"0.6404426",
"0.6403605",
"0.6393535",
"0.6371468",
"0.63690346",
"0.6367587",
"0.63659185",
"0.6363864",
"0.63624924",
"0.63524586",
"0.634856",
"0.6345434",
"0.63445467",
"0.63409895",
"0.633097",
"0.63295746",
"0.6326185",
"0.63226116",
"0.632142",
"0.6318301",
"0.6316841",
"0.63166165",
"0.63156444",
"0.63125473",
"0.63122916",
"0.63122916",
"0.6307996",
"0.6307372",
"0.6303371",
"0.62933534",
"0.62849957",
"0.6281395",
"0.6280768",
"0.62786937",
"0.6275867",
"0.627582",
"0.62705326",
"0.627013",
"0.6264271",
"0.62628233",
"0.6260489",
"0.62516516",
"0.6249469",
"0.62462217",
"0.6245316",
"0.62436813",
"0.62436813",
"0.62436813",
"0.62436813",
"0.62426627",
"0.6238968",
"0.623527",
"0.62348413",
"0.6234813",
"0.6234058",
"0.6233039",
"0.6231338",
"0.62296",
"0.6227509",
"0.622343",
"0.6221648",
"0.62199455",
"0.62190235",
"0.6218847",
"0.6218449",
"0.6216105",
"0.6215605",
"0.62133837",
"0.6212587",
"0.62120795",
"0.6202005",
"0.62015796",
"0.62001127",
"0.6199301",
"0.6199017",
"0.6195458",
"0.61953944",
"0.61953944",
"0.6192611",
"0.61921203",
"0.6190604",
"0.6190467",
"0.61897373"
] | 0.65439785 | 6 |
Use callbacks to share common setup or constraints between actions. | def set_bar68
@bar68 = Bar68.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup_handler\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def workflow\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def setup\n # override and do something appropriate\n end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def before_action \n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def setup_signals; end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def after_set_callback; end",
"def initialize(*args)\n super\n @action = :set\nend",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def around_hooks; end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def call\n setup_context\n super\n end",
"def duas1(action)\n action.call\n action.call\nend",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] | [
"0.6163754",
"0.6045816",
"0.5944853",
"0.59169096",
"0.58892167",
"0.58342934",
"0.5776148",
"0.57057375",
"0.57057375",
"0.56534296",
"0.56209534",
"0.54244673",
"0.54101455",
"0.54101455",
"0.54101455",
"0.53951085",
"0.5378493",
"0.53563684",
"0.53399915",
"0.5338049",
"0.53307265",
"0.5312121",
"0.5298173",
"0.5296388",
"0.52952695",
"0.5258086",
"0.52430934",
"0.5237911",
"0.5237911",
"0.5237911",
"0.5237911",
"0.5237911",
"0.52335346",
"0.5232943",
"0.5226392",
"0.52221715",
"0.5217978",
"0.52136153",
"0.52076435",
"0.52067244",
"0.5175402",
"0.5174649",
"0.5173085",
"0.5165201",
"0.5162052",
"0.5157932",
"0.5152905",
"0.5152353",
"0.5150909",
"0.514719",
"0.5138596",
"0.51333916",
"0.51139015",
"0.5113431",
"0.5113431",
"0.5109581",
"0.51066816",
"0.5091428",
"0.5089407",
"0.5082971",
"0.50822043",
"0.50668514",
"0.5055155",
"0.50525695",
"0.50499475",
"0.50499475",
"0.5034445",
"0.50249445",
"0.5022226",
"0.50167644",
"0.5014211",
"0.4999924",
"0.49996212",
"0.49978727",
"0.4989682",
"0.4989682",
"0.49851838",
"0.49817684",
"0.4979687",
"0.49787104",
"0.49688423",
"0.49664098",
"0.49564412",
"0.49561828",
"0.49547398",
"0.4953481",
"0.4952925",
"0.4946049",
"0.494379",
"0.49319315",
"0.49313048",
"0.49269778",
"0.49263066",
"0.49257493",
"0.4924526",
"0.49212465",
"0.49173486",
"0.4915802",
"0.49151486",
"0.49150333",
"0.49147308"
] | 0.0 | -1 |
Only allow a list of trusted parameters through. | def bar68_params
params.require(:bar68).permit(:foo1, :foo2, :foo3, :foo4, :foo5)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def allow_params_authentication!; end",
"def whitelisted_args\n args.select &:allowed\n end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def filtered_parameters; end",
"def sanitize_params_for user, params, allowed_params\n params.each do |key, val|\n #if allowed_params.include?(key)\n #sanitize!(user, params, key) if key =~ /_attributes|_ids$/\n #else\n #params.delete(key)\n #end\n params.delete(key) unless allowed_params.include?(key.to_sym)\n end\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def expected_permitted_parameter_names; end",
"def sanitize_parameters!(sanitizer, params)\n # replace :readwrite with :onlyif\n if params.has_key?(:readwrite)\n warn \":readwrite is deprecated. Replacing with :onlyif\"\n params[:onlyif] = params.delete(:readwrite)\n end\n\n # add default parameters\n bindata_default_parameters.each do |k,v|\n params[k] = v unless params.has_key?(k)\n end\n\n # ensure mandatory parameters exist\n bindata_mandatory_parameters.each do |prm|\n if not params.has_key?(prm)\n raise ArgumentError, \"parameter ':#{prm}' must be specified \" +\n \"in #{self}\"\n end\n end\n\n # ensure mutual exclusion\n bindata_mutually_exclusive_parameters.each do |param1, param2|\n if params.has_key?(param1) and params.has_key?(param2)\n raise ArgumentError, \"params #{param1} and #{param2} \" +\n \"are mutually exclusive\"\n end\n end\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def check_params; true; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def allowed?(*_)\n true\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def allowed_params(parameters)\n parameters.select do |name, values|\n values.location != \"path\"\n end\n end",
"def secure_params\n return @secure_params if @secure_params\n\n defn = implementation_class.definition\n field_list = [:master_id] + defn.field_list_array\n\n res = params.require(controller_name.singularize.to_sym).permit(field_list)\n res[implementation_class.external_id_attribute.to_sym] = nil if implementation_class.allow_to_generate_ids?\n @secure_params = res\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permit( params, whitelist, name = nil )\n raise 'Parametrization not yet configured' unless @configured\n whitelist ||= []\n px = params.respond_to?( :permit ) ? params : ActionController::Parameters.new( params )\n px = dig(px, name)\n px.permit( *whitelist )\n end",
"def valid_params?; end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def url_allowlist=(_arg0); end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def list_params\n params.permit(:list_name)\n end",
"def valid_params_request?; end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def param_list(param_type, name, type, required, description = nil, allowed_values = [], hash = {})\n hash.merge!({allowable_values: {value_type: \"LIST\", values: allowed_values}})\n param(param_type, name, type, required, description, hash)\n end",
"def safelists; end",
"def authorize_own_lists\n authorize_lists current_user.lists\n end",
"def listed_params\n params.permit(:listed, :list_id, :listable_id, :listable_type, :campsite_id)\n end",
"def lists_params\n params.require(:list).permit(:name)\n\n end",
"def list_params\n params.require(:list).permit(:name, :user_id)\n end",
"def list_params\n params.require(:list).permit(:name, :description, :type, :privacy, :allow_edit, :rating, :votes_count, :user_id)\n end",
"def check_params\n true\n end",
"def authorize_own_or_shared_lists\n authorize_lists current_user.all_lists\n end",
"def user_pref_list_params\n\t\tparams.require(:user).permit(:preference_list)\n\tend",
"def may_contain!(*keys)\n self.allow_only_permitted = true\n self.permitted_keys = [*permitted_keys, *keys].uniq\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def whitelist; end",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.permit(:name)\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :list, :references)\n end",
"def cancan_parameter_sanitizer\n resource = controller_name.singularize.to_sym\n method = \"#{resource}_params\"\n params[resource] &&= send(method) if respond_to?(method, true)\n end",
"def list_params\n params.require(:list).permit(:name).merge(user_id: current_user.id)\n end",
"def whitelist_place_params\n params.require(:place).permit(:place_name, :unlock, :auth, :is_deep_checked, :parent_ADM4, :parent_ADM3, :parent_ADM2, :parent_ADM1, :parent_country, feature_code: [], same_as: [], related_authority: [], altlabel: [], note: []) # Note - arrays need to go at the end or an error occurs!\n end",
"def list_params\n params.fetch(:list, {}).permit(:user_id, :name, :active)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def secure_params(require_param, permit_keys)\n params.require(require_param).permit(*permit_keys)\n end",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def permitted_params\n []\n end",
"def price_list_params\n params.fetch(:price_list, {}).permit(:name, :valid_from, :valid_to, :active,\n :all_warehouses, :all_users, :all_contact_groups,\n warehouse_ids: [], price_lists_user_ids: [], contact_group_ids: [])\n end",
"def params(list)\n @declared_params = list\n end",
"def admin_review_params\n params.fetch(:review, {}).permit(whitelisted_params)\n end",
"def saved_list_params\n params.require(:saved_list).permit(:user_id)\n end",
"def allow(ids); end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def filter_params(param_set, **kwargs)\r\n begin\r\n key = kwargs[:key]\r\n params.require(key).permit(*param_set)\r\n rescue Exception\r\n params.permit(*param_set)\r\n end\r\n end",
"def valid_parameters\n sort_symbols(@interface.allowed_parameters)\n end",
"def validate_paramified_params\n self.class.paramify_methods.each do |method|\n params = send(method)\n transfer_errors_from(params, TermMapper.scope(params.group)) if !params.valid?\n end\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def secure_params\n return @secure_params if @secure_params\n\n @implementation_class = implementation_class\n resname = @implementation_class.name.ns_underscore.gsub('__', '_').singularize.to_sym\n @secure_params = params.require(resname).permit(*permitted_params)\n end",
"def refine_permitted_params(param_list)\n res = param_list.dup\n\n ms_keys = res.select { |a| columns_hash[a.to_s]&.array }\n ms_keys.each do |k|\n res.delete(k)\n res << { k => [] }\n end\n\n res\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :description, recipient_id_array: [])\n end",
"def safelist; end",
"def sponsor_params\n params.require(:sponsor).permit(WHITE_LIST)\n end",
"def valid_for_params_auth?; end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def shopping_list_params\n params.require(:shopping_list).permit!\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def permitters\n @_parametrizr_permitters || {}\n end",
"def allow_params(action, keys: nil, except: nil, &blk)\n keys &&= Array.wrap(keys)\n keys ||= User.field_names\n except &&= Array.wrap(except)\n except ||= %i[id email]\n devise_parameter_sanitizer.permit(action, keys: keys, except: except, &blk)\n end",
"def list_params\n if current_user && current_user.role == 'admin'\n params.require(:list).permit(:name, :url, :description, :user_id,\n ideas_attributes: [:id, :list_id, :body, :due_date, :completion_status, :_destroy])\n else\n params.require(:list).permit(:name, :description,\n ideas_attributes: [:body, :due_date, :completion_status]) \n end\n end",
"def whitelist(params)\n send_request_of_type(GlobalConstant::PrivateOpsApi.private_ops_api_type, 'post', '/token-sale/whitelist', params)\n end",
"def valid_access_params\n params.require(:valid_access).permit(:wish_list_id, :user_id)\n end",
"def url_allowlist; end",
"def ensure_redirected_params_are_safe!(passed_params)\n unless passed_params.is_a?(ActionController::Parameters) && passed_params.permitted?\n error_message = if passed_params.is_a?(ActionController::Parameters)\n unsafe_parameters = passed_params.send(:unpermitted_keys, params)\n \"[Rails::Prg] Error - Must use permitted strong parameters. Unsafe: #{unsafe_parameters.join(', ')}\"\n else\n \"[Rails::Prg] Error - Must pass strong parameters.\"\n end\n raise error_message\n end\n end",
"def data_collection_params\n allow = [:name,:description,:institution,:collection_name,:country_id,:province_id,:city_id]\n params.require(:data_collection).permit(allow)\n end",
"def quote_params\n params.permit!\n end"
] | [
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.6326454",
"0.63140553",
"0.6299814",
"0.62642586",
"0.626006",
"0.62578833",
"0.6236823",
"0.6227561",
"0.6221758",
"0.62200165",
"0.620879",
"0.61983657",
"0.6195055",
"0.6172993",
"0.6156856",
"0.61558664",
"0.61521494",
"0.6135789",
"0.6121145",
"0.61118174",
"0.60736513",
"0.6071645",
"0.60632104",
"0.60549796",
"0.6043906",
"0.6034662",
"0.60207325",
"0.6018568",
"0.6016575",
"0.60103434",
"0.60084206",
"0.600763",
"0.6007443",
"0.6003619",
"0.6003619",
"0.5995791",
"0.5993301",
"0.5993231",
"0.5984926",
"0.597122",
"0.5968121",
"0.5965808",
"0.59640145",
"0.59632224",
"0.59602356",
"0.59332967",
"0.5927556",
"0.5922805",
"0.5909745",
"0.5905083",
"0.5904304",
"0.5893434",
"0.58888215",
"0.58823985",
"0.58823985",
"0.58823985",
"0.5873434",
"0.58619875",
"0.58533794",
"0.5845531",
"0.58426666",
"0.58360124",
"0.583218",
"0.5828041",
"0.5827927",
"0.5816121",
"0.5814705",
"0.5812719",
"0.581121",
"0.5803423",
"0.5803423",
"0.57995003",
"0.5794207",
"0.5784923",
"0.5781365",
"0.5776385",
"0.5774859",
"0.57671493",
"0.5766998",
"0.57618684",
"0.5758038"
] | 0.0 | -1 |
actually might not need the new and create actions since user registration is being handled by devise | def new
@student = Student.new
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_user\n \n end",
"def newUser\n end",
"def create\n\n (super and return) if request.format.html?\n\t user = User.new(allow_registration_parameters)\n\t if user.save\n\t render :json=> { :status => 201, :user => user , :token => user.authentication_token }\n\t return\n\t else\n\t warden.custom_failure!\n errors = user.errors.full_messages.join(\"<br/>\").html_safe\n\t render :json=> {:status=>422,:message => errors}\n\t end\n\tend",
"def devise_create_new_rails_user\n build_resource(sign_up_params)\n\n resource.save\n\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message :notice, :signed_up if is_flashing_format?\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message :notice, :\"signed_up_but_#{resource.inactive_message}\" if is_flashing_format?\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n end",
"def new\n\t\t#super\n\t\t# Overwriting /signup method to redirect to users/new \n\t\t respond_to do |format|\n format.html { redirect_to new_user_path }\n end\n\tend",
"def registration\n \t@user = User.new\n end",
"def create\n if resource.active_invitation? && !resource.new_record?\n # The user record already existed\n if resource.update(sign_up_params)\n resource.accept_invitation\n\n # Follow the standard Devise logic to sign in\n set_flash_message! :notice, :signed_up\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n # Follow the standard Devise failed registration logic\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n elsif !Rails.configuration.x.recaptcha.enabled || verify_recaptcha(action: 'register')\n\n # Devise doesn't set a flash message for some reason if its going to fail\n # so do it here\n super do |user|\n flash[:alert] = _('Unable to create your account!') unless user.valid?\n\n # Attach the Shib eppn if this is part of an SSO account creation\n hash = session.fetch('devise.shibboleth_data', {})\n if hash.present? && user.valid?\n user.attach_omniauth_credentials(scheme_name: 'shibboleth',\n omniauth_hash: hash)\n end\n end\n else\n flash[:alert] = _('Invalid security check! Please make sure your browser is up to date and then try again')\n end\n end",
"def create_user_information # for new users. runs last according to rails.\n self.dj_name = name\n self.roles = Role.where(:title => 'noob')\n self.active = true\n set_password\n end",
"def create\n @user = User.new(user_params)\n\n # save was requested by either current_user or else must be a new registration\n if @user.save(current_user)\n redirect_to users_path\n else\n render('new', status: :unprocessable_entity)\n end\n end",
"def new_user\n\t\t@resource = User.new\n\t\t@resource_name = 'user'\n\tend",
"def create\n if params[:user][:password].blank?\n password = SecureRandom.base64(10)\n params[:user][:password] = password\n params[:user][:password_confirmation] = password\n end\n\n # Copied from devise-4.6.1/app/controllers/devise/registrations_controller.rb\n build_resource(sign_up_params)\n\n resource.save\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n # sign_up(resource_name, resource)\n # respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n # respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n\n resource.send_account_created_instructions\n else\n clean_up_passwords resource\n set_minimum_password_length\n # respond_with resource\n end\n @users = User.order(:last_name, :first_name)\n @user = current_user\n\n if @user.nil?\n redirect_to :root, notice: \"You have been signed up. Please check your email to set a password and complete your registration.\"\n else\n render :index\n end\n end",
"def new\n if logged_in?\n # User who has logged in has no need to access create action\n redirect_to current_user\n else\n # Get ready to display signup page by declaring instance var\n \t @user = User.new\n end\n end",
"def create\n \t@user = User.new(user_params)\n if @user.save\n redirect_to login_path, notice: \"The registration success, you can login now.\"\n else\n render 'new'\n end\n end",
"def register\n if request.get? then\n @user = User.new\n end\n # Запрос на создание нового пользователя\n if request.post? then\n @user = User.new(params[:user])\n # Если включена регистрация по инвайтам - проверяем правильность введённого кода\n if SiteGlobal.invite_reg && !Invite.valid?(params[:invite]) then\n @user.errors[:base] << \"Invalid invation code\"\n render :register and return\n end\n # Пользователь может создать только аккаунт студента или преподавателя\n render_403 and return unless User.in_user_group?(@user)\n # Если запись успешно создана\n if @user.save then\n # Создание записи в дополнительной таблице\n if @user.student? then\n Student.create(user_id: @user.id)\n elsif @user.lecturer? then\n Lecturer.create(user_id: @user.id, confirm_level: Lecturer::CONFIRM_LEVELS[:unconfirmed])\n end\n if SiteGlobal.invite_reg\n Invite.use(params[:invite])\n end\n login, password = params[:user][:login], params[:user][:password]\n session[:user_id] = User.authenticate(login, password).id\n if @user.lecturer? then\n redirect_to settings_lecturer_path(reg: 1)\n elsif @user.student? then\n redirect_to settings_student_path(reg: 1)\n else\n redirect_to :root\n end\n else\n render :register\n end\n end\n end",
"def create\n if Feedbunch::Application.config.signups_enabled\n super\n else\n Rails.logger.warn \"Creation of new user attempted, but signups are disabled\"\n redirect_to root_path\n end\n end",
"def register\n if @user.blank? || ([email protected]_registered && @user.tips.count == 0 && @user.votes.count == 0)\n redirect_to :profile, alert: \"Registration Impossible. There is nothing to register\"\n elsif @user.is_registered\n redirect_to :profile, alert: \"Registration Impossible. Account already registered\"\n else\n if @user.register(user_registration_params.to_h)\n #cookies.delete(\"user_id\") #don't delete the cookie, just in case I'm logging in on someone else's device.\n sign_in @user\n redirect_to :profile, notice: \"Account successfully registered. You can now login from anywhere !\"\n else\n redirect_to :profile, alert: \"Registration failed. #{@user.errors.full_messages.to_sentence}\"\n end\n end\n end",
"def create\n build_resource(sign_up_params)\n\n respond_to do |format|\n if resource.save\n format.html { redirect_to admin_root_path, notice: 'User was successfully created.' }\n format.json { render json: @user, status: :created, location: @user }\n else\n format.html { render action: \"new\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end \n\n if resource.save\n if resource.active_for_authentication?\n set_flash_message :notice, :signed_up if is_navigational_format?\n sign_up(resource_name, resource)\n respond_with resource, :location => after_sign_up_path_for(resource)\n else\n set_flash_message :notice, :\"signed_up_but_#{resource.inactive_message}\" if is_navigational_format?\n expire_session_data_after_sign_in!\n respond_with resource, :location => after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n respond_with resource\n end\n end",
"def registration\n \tif request.post?\n user = User.new(user_params)\n if user.valid?\n user.save\n flash[:notice] = \"Registration Successful. Please Sign In!\"\n redirect_to root_url\n else\n flash[:alert] = user.errors.first[1]\n redirect_to users_registration_url\n end\n \tend\t\n end",
"def new\n\n if signed_in? && !isAdmin?\n sign_out\n redirect_to signup_url\n elsif signed_in? && isAdmin?\n redirect_to \"/new_prof\"\n end\n @title= \"Sign Up\"\n @user = User.new\n\n \n end",
"def new_user\n \trender action: 'new_user'\n end",
"def create_user\n super\n end",
"def new_user\n\t @user = User.new\t \n\tend",
"def create\n if !current_user || is_admin?\n @user = User.new(params[:user])\n\n respond_to do |format|\n if @user.save\n format.html { redirect_to(:root, :notice => 'Registration successfull.') }\n #format.xml { render :xml => @user, :status => :created, :location => @user }\n else\n format.html { render :action => \"new\" }\n #format.xml { render :xml => @user.errors, :status => :unprocessable_entity }\n end\n end\n else\n redirect_to :root\n end\n end",
"def registration\n @saas = SETTINGS['saas_registration_mode']\n @user = User.new\n initialize_registration_form\n @errors = {\n :general => [],\n :subjects => [],\n :policies => [],\n :purchase => []\n }\n end",
"def create\n @user = User.find_by_email_and_activated(params[:user][:email], false) # We can only register a user that hasn't been activated yet.\n \n if @user\n # Cases 2 and 3.\n params[:user].delete(:email) # They can't arbitrarily change their email address.\n @user.update_attributes(params[:user])\n else\n # Case 1.\n @user = User.new(params[:user].merge({:perishable_token => \"\"}))\n @user.reset_perishable_token!\n end\n \n # This is true when a user finishes their registration from a link in their email (Case 3),\n # which means we don't need to send an activation link.\n if params[:token] && User.find_using_perishable_token(params[:token], 0) == @user\n activate\n else\n # Cases 1 and 2. \n # Saving without session maintenance to skip\n # auto-login which can't happen here because\n # the user has not yet been activated\n if @user.save_without_session_maintenance\n @user.deliver_activation_instructions\n flash[:notice] = 'Registration successful. Please check your email to activate your account.'\n redirect_to shares_path\n else\n flash[:error] = 'Registration failed. Please try again.'\n redirect_to root_path\n end\n end\n end",
"def create\n # Slight modification of the devise create function\n build_resource(sign_up_params)\n resource.save\n resource.add_role params[:role]\n\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n end\n \n # Gather all users so table can be rendered\n @users = User.all\n render \"manage\"\n end",
"def new\n\t\tmissing unless WAYGROUND['ALLOW_SIGNUP']\n\t\t@user = User.new(params[:user])\n\t\[email protected]_zone = Time.zone.name unless params[:user]\n\t\[email protected]? if params[:user]\n\t\t@page_title = 'New User Registration'\n\tend",
"def configure_devise_permitted_parameters\n registration_params = [:userid]\n\n if params[:action] == 'create'\n devise_parameter_sanitizer.for(:sign_up) do\n |u| u.permit(registration_params)\n end\n end\nend",
"def create\n fname = \"#{self.class.name}.#{__method__}\"\n super\n user=User.find_by_email(reg_params[:email])\n pars={}\n unless user.nil?\n pars[:name]=params[:user][:name]\n pars[:role]=params[:user][:role]\n user.update(pars) \n else\n user=User.new(params[:user])\n end\n LOG.debug(fname) {\"************************ current_user=#{user.inspect}\"}\n end",
"def new_user_handler\n nil\n end",
"def create\n @user = User.new(params[:user])\n if @user.save\n flash[:notice] = 'Registration successfull.' \n redirect_to root_url\n else\n render :action => \"new\"\n end\n end",
"def new\n @user = User.new\n \n respond_to do |format|\n format.html do\n case params[:registration_method] \n when 'third_party'\n redirect_to new_third_party_registration_path\n end\n end\n end\n end",
"def create\n build_resource\n @users = User.find(:all, :include => :roles) \n debugger\n if resource.save\n if resource.active_for_authentication?\n sign_in(resource_name, resource)\n (render(:partial => 'newuser', :locals => {:user => resource.id}, :layout => false) && return) if request.xhr?\n respond_with resource, :location => after_sign_up_path_for(resource)\n else\n expire_session_data_after_sign_in!\n (render(:partial => 'newuser', :locals => {:user => resource.id}, :layout => false) && return) if request.xhr?\n respond_with resource, :location => after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n render :action => :new, :layout => !request.xhr?\n end\n end",
"def create_user\n\n security_code = SecureRandom.hex(4)\n user = User.new(name: params[:name], email: params[:email], password: security_code, password_confirmation: security_code)\n if user.valid?\n if user.save\n # Aplica lo logica necesaria\n #ApplicationMailer.registration_candidate(user, security_code).deliver# notifica el registro por correo\n @log.current_user = user\n @log.registration_auditory(controller_name + '/' + __method__.to_s, Constant::CONST_REGISTER_CANDIDATE, request.remote_ip)\n render json: {status: 200, payload: {message: Constant::CONST_CANDIDATE_REGISTRED, type: Constant::CONST_TYPE_FLASH_MESSAGE_SUCESS}}\n else\n # almacena el error y notifica al administrador del sistema\n #ApplicationMailer.registration_error(@log.registration_error(user.errors.full_messages, controller_name + '/' + __method__.to_s, Constant::CONST_INITIAL_PASSWORD, request.remote_ip)).deliver\n render json: {status: 500, payload: {message: Constant::CONST_INTERNAL_SERVER_ERROR, type: Constant::CONST_TYPE_FLASH_MESSAGE_ERROR}}\n end\n else\n render json: {status: 400, payload: {message: user.errors.full_messages.first.gsub(user.errors.full_messages.first.split[0]+' ','') , type: Constant::CONST_TYPE_FLASH_MESSAGE_ERROR}}\n end\n end",
"def create\n build_resource(sign_up_params)\n\n resource.save\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n # sign_up(resource_name, resource)\n # respond_with resource, location: after_sign_up_path_for(resource)\n\n # mailer\n AccountMailer.account_email(resource).deliver\n\n # devise override\n # （サインアップしたユーザーでログインせずadminページにリダイレクト）\n redirect_to admin_path\n\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n end",
"def create \n\t\t@user=User.new\n\t\[email protected]=\"native\"\n\t\[email protected]_attributes(signup_params)\n\t\[email protected]!\n\t\tflash[:success]=\"Thanks for joining SPACEF!T, #{@user.name ||\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\[email protected](\"@\").first }. \"\n\t\tsign_in!(@user, true)\n\t\tredirect_to root_path\n\trescue ActiveRecord::RecordInvalid,\n\t\t\t\t\tActiveRecord::RecordNotUnique => e\n\t\tflash.now[:error]=\"We were not able to sign you up, please correct the following fields\"\n\t\[email protected]\n\t\trender 'new'\n\tend",
"def create\n \n build_resource(sign_up_params)\n\n #this is a private function to check params\n if check_some_validations\n redirect_to new_user_registration_path\n else #the next part taken form Devise on github\n resource.save\n yield resource if block_given?\n\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n end\n end",
"def create\n build_resource(sign_up_params)\n\n resource.save\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n sign_up(resource_name, resource)\n # respond_with resource, location: after_sign_up_path_for(resource)\n render 'users/registrations/finish_registration'\n # redirect_to(controller: \"custom_registration\", action: \"index\") and return\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n # respond_with resource, location: after_inactive_sign_up_path_for(resource)\n render 'users/registrations/finish_registration'\n # redirect_to(controller: \"custom_registration\", action: \"index\") and return\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n end",
"def create\n\n #Make sure only logged in admins can manipulate users\n\n if @loggedinuser && @loggedinuser.authorizationlevel >= 4\n\n @user = User.new(params[:user])\n if @user.save\n redirect_to :action => 'index'\n else\n render 'new'\n end\n #Make sure only non-logged in users can register\n elsif ! @loggedinuser\n #Register a new user from data provided by the form. If the save fails for\n #some reason, redirect back to the form so that errors can be corrected and tried again.\n @user = User.new(params[:user])\n\[email protected]=1\n if @user.save\n redirect_to '/welcome/login'\n else\n render 'register'\n end\n else \n redirect_to '/'\n end\n end",
"def create\n super and return unless current_user\n @user = User.new(user_params)\n redirect_path = params[:redirect_path].present? ? params[:redirect_path] : users_path\n @user.password = @user.password_confirmation = SecureRandom.hex(6)\n respond_to do |format|\n if @user.save\n format.html { redirect_to redirect_path, notice: 'user was successfully created.' }\n format.json { render :show, status: :created, location: @user }\n else\n format.html { render :new }\n format.js { render \"users/new\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end \n end",
"def create\n # Wenn Formular abgeschickt\n if ! params[:user].nil?\n if params[:user][:password] == params[:user][:password2] \n # Wird gesetzt damit die Create-Forms verschwinden\n @inputs = true; \n # entferne Passwortwiederhohlung aus den Parametern um User zu erzeugen\n params[:user].delete(:password2) \n # Erster Benutzer muss Admin sein\n if User.find(:all).length == 0\n params[:user][:access]=\"admin\"\n else\n params[:user][:access]=\"leecher\"\n end\n @newuser = User.new(params[:user])\n # @created wird gesetzt zur erstellungsmessage, da komischerweise ein\n # zugriff auf @newuser.valid? nicht fruchtet\n if @newuser.valid?\n @created=true\n # Wenn user Admin ist,(erste anmeldung) setze die Variable un erstelle ein basis genre\n if params[:user][:access]==\"admin\"\n @admin = true\n Genre.create(:name => \"unknown\")\n end\n end\n @newuser.save\n else \n # Wenn diese Variable nil ist, sind beide Passwörter nicht gleich\n @bothpw=true\n end \n end\n respond_to do |format|\n format.html \n format.xml \n end\n end",
"def create\n build_resource(sign_up_params)\n resource.name = params[:user][:name] if not params[:user][:name].blank?\n resource_saved = resource.save\n yield resource if block_given?\n if resource_saved\n if resource.active_for_authentication?\n set_flash_message :alert, :signed_up if is_flashing_format?\n sign_up(resource_name, resource)\n\n if request.referer && resource\n if request.referer.to_s.include? ('courses/activate')\n redirect_to '/courses/activate'\n return\n end\n end\n\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message :alert, :\"signed_up_but_#{resource.inactive_message}\" if is_flashing_format?\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n set_flash_message :alert, :invalid_email if is_flashing_format?\n clean_up_passwords resource\n @validatable = devise_mapping.validatable?\n if @validatable \n @minimum_password_length = resource_class.password_length.min\n set_flash_message :alert, :invalid_email if is_flashing_format?\n end\n respond_with resource\n end\n end",
"def signup\n end",
"def signup\n end",
"def create\n @user=User.new(params[:user])\n if [email protected]?\n pw_hash = Digest::MD5.hexdigest(@user.password)\n #if validation was ok we can update the user\n if @user.save\n #update pw with hash\n @new_user = User.find(@user.id)\n @new_user.password = pw_hash\n #set user status to inactive\n @new_user.status = false;\n #generate random token for confirmation mail\n uuid = UUID.new\n @new_user.registration_token = uuid.generate\n @new_user.save\n #send the mail\n Notifier.send_registration_confirmation(@new_user).deliver\n flash[:notice] = \"User was successfully created\"\n redirect_to :root\n else\n render :action => \"/new\"\n end\n\n else\n render :action => \"/new\"\n end\n\n end",
"def create\n @user = User.new(params[:user])\n #o usuário está sendo criado no devise registration.\n\t\n respond_to do |format|\n if @user.save\n format.html { redirect_to @user, :notice => 'User was successfully created.' }\n format.json { render :json => @user, :status => :created, :location => @user }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @user.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n if logged_in?\n # User who has logged in has no need to access create action\n redirect_to current_user\n else \n # Ready to create new user\n @user = User.new(params[:user])\n if @user.save\n # Handle a successful save.\n log_in @user\n flash[:success] = \"Welcome to the Sample App!\"\n redirect_to @user\n else\n \t# Render signup page\n render 'new'\n end\n end\n end",
"def new\n #showing the registration page\n end",
"def new\n super\n @title = \"Sign up\"\n logger.debug \"\\n\\t RegistrationsController#new \\n\\n\"\n end",
"def create\n @title = 'Users Management'\n @breadcrumb = 'Users > New'\n @user = User.new(user_params)\n\n respond_to do |format|\n if @user.save\n format.html {\n if @user.user_type.name == 'customer'\n redirect_to login_url, notice: 'Registration is completed. Please login'\n else\n redirect_to @user, notice: 'User was successfully created.'\n end\n }\n format.json { render :show, status: :created, location: @user }\n else\n format.html {\n if @user.user_type.name == 'customer'\n redirect_to registrations_path, alert: @user.errors.full_messages.to_sentence\n else\n redirect_to new_user_path, alert: @user.errors.full_messages.to_sentence\n end\n }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n if params[:index_register].present?\n @user = User.new(:email => params[:email], :password => params[:password], :password_confirmation => params[:password])\n else\n @user = User.new(params[:user])\n end\n\n respond_to do |format|\n if @user.save\n session[:user_id] = @user.id\n UserMailer.verification_email(@user).deliver\n format.html { redirect_back_or_default links_path} #notice: 'User was successfully created.' \n format.json { render json: @user, status: :created, location: @user }\n else\n #MC -- this is a mess..\n format.html { redirect_to root_path, :notice => [:email, :password].collect{|i| @user.errors[i]}.flatten}\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def sign_up(resource_name, resource)\n redirect_to users_url\n end",
"def new\n @title = \"Sign-In or Register\"\n @user = User.new\n\n end",
"def register\n # running successfully\n # class_name = params[:user_type].camelize\n # registration_stuff = params[\"#{params[:user_type].to_sym}\"]\n # template = \"#{params[:user_type].pluralize}/new\"\n # save_credentials(class_name, registration_stuff, template)\n\n if(params[:user_type] == 'job_seeker')\n class_name = \"JobSeeker\"\n registration_stuff = params[:job_seeker]\n template = \"job_seekers/new\"\n save_credentials(class_name, registration_stuff, template)\n else\n class_name = \"Employer\"\n registration_stuff = params[:employer]\n template = \"employers/new\"\n save_credentials(class_name, registration_stuff, template)\n end\n end",
"def create\n if user.save\n redirect_to users_path\n else\n render 'new'\n end\n end",
"def create\n @user = User.new(user_params)\n if @user.save\n UserMailer.registration_confirmation(@user).deliver\n redirect_to root_url, notice: \"Thank-you for enrolling!\"\n else\n render \"new\"\n end\n end",
"def register_create\n begin\n user_create('devise/registrations/register')\n rescue => e\n Rails.logger.error APP_CONFIG['error'] + \"(#{e.message})\" + \",From:app/controllers/registrations_controller.rb ,Action:restaurant_create\"\n flash.now[:alert] = '發生錯誤! 註冊失敗!'\n render 'devise/registrations/register'\n end\n end",
"def configure_permitted_parameters\n registration_params = [:password , :email, :username, :first_name, :last_name]\n\n if params[:action] == 'create'\n devise_parameter_sanitizer.permit(:sign_up) do\n |u| u.permit(registration_params)\n end\n end\n end",
"def new\n\t@allowNewUsers = false\n\tif @allowNewUsers == false\n\t\tredirect_to :controller => 'home'\n\t\tflash[:notice] = 'Registering is currently disabled, thank you.' \n\telse\n\t\tif current_user \n\t\t\t@user = User.find(current_user) \n\t\tend\n\t\tif !params[:code]\n\t\t @user = User.new\n\n\t\t respond_to do |format|\n\t\t format.html # new.html.erb\n\t\t format.json { render json: @user }\n\t\t end\n\t \n\t\telse code = params[:code]\n\t\t\tif code\n\t\t\t\tcode_components = code.split(/_/)\n\t\t\t\tif code_components.length == 2\n\t\t\t\t\t@user = User.find(code_components[0])\n\t\t\t\t\tif @user and @user.verify_id_digest(code_components[1])\n\t\t\t\t\t\[email protected] = true\n\t\t\t\t\t\[email protected]\n\t\t\t\t\t\trespond_to do |format|\n\t\t\t\t\t\t\tflash[:notice] = 'Welcome! You are a valid user, you can now logon.'\n\t\t\t\t\t\t\tformat.html {redirect_to(:controller => 'home', :action => 'index')}\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\t\n\t\tend\t \n\tend\n end",
"def create\n @user = User.new(params[:user])\n if @user.openid_url.nil? || @user.openid_url.blank?\n handle_traditional_registration\n else\n handle_openid_registration\n end\n end",
"def create\n build_resource(sign_up_params)\n\n resource.save\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n redirect_to new_matcher_registration_path, notice: error_al_registrar(resource)\n end\n end",
"def new\n\t@user = User.new\n\t@title = \"Sign up\"\n end",
"def new\n # Diese Seite ist User-unabhängig\n @independent = true\n @action = \"Registrieren\"\n @header = {\"back\" => root_path, \"ajax\" => true, \"title\" => \"Registrieren\"}\n @user = User.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @user }\n end\n end",
"def create\n\t\tredirect_to '/users/sign_in', alert: 'Access denied.'\n\tend",
"def create\n build_resource sign_up_params\n\n if resource.save\n Notifier.notify_superusers_of_access_request(resource).deliver\n if resource.active_for_authentication?\n set_flash_message :notice, :signed_up if is_navigational_format?\n sign_in(resource_name, resource)\n respond_with resource, :location => after_sign_up_path_for(resource)\n else\n set_flash_message :notice, :\"signed_up_but_#{resource.inactive_message}\" if is_navigational_format?\n expire_session_data_after_sign_in!\n respond_with resource, :location => after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n respond_with resource\n end\n end",
"def create\n build_resource(registration_params)\n\n #Find the email entered by the guest in the User table in the database \n @userTemp = User.where(email: resource.email).first\n \n #If user doesn't exist\n if @userTemp.nil?\n\n \t#Save it in the database\n\t if resource.save\n\t set_flash_message :notice, :signed_up\n\t sign_up(resource_name, resource)\n\t respond_with resource, :location => after_sign_up_path_for(resource)\n\t else\n\t #clean_up_passwords\n\t respond_with resource\n\t end\n\telse\n\t\t#If user already exists, go to registration url and show an error message\n\t\tredirect_to new_user_registration_url, :flash => { :error => \"Email already registered! Please Sign Up using another email!\" }\n\tend\n\n end",
"def create\n @user = User.new(user_params)\n\n if @user.create_first\n flash[:message] = t('welcome', scope: 'refinery.authentication.devise.users.create', who: @user)\n sign_in(@user)\n redirect_back_or_default(Refinery::Core.backend_path)\n else\n render :new\n end\n end",
"def create\n build_resource(sign_up_params)\n\n resource_saved = resource.save\n yield resource if block_given?\n if resource_saved\n if resource.active_for_authentication?\n set_flash_message :notice, :signed_up if is_flashing_format?\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message :notice, :\"signed_up_but_#{resource.inactive_message}\" if is_flashing_format?\n expire_data_after_sign_in!\n redirect_to :new_user_session, flash: {notice: \"Seu registro foi efetuado com sucesso! Por favor aguarde a aprovação do admnistrador!\"}\n end\n else\n clean_up_passwords resource\n @validatable = devise_mapping.validatable?\n if @validatable\n @minimum_password_length = resource_class.password_length.min\n end\n respond_with resource\n end\n # redirect_to :back, flash: {error: \"Oops, something went wrong. Please try again\"}\n end",
"def create\n @user = User.new(sign_up_params)\n\t\[email protected] = 0\n respond_to do |format|\n if @user.save\n format.html { redirect_to url_for({controller: :users, action: :sign_in, id: 0}), notice: 'User was successfully created.' }\n format.json { render :show, status: :created, location: @user }\n else\n format.html { render :new }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @user = User.new(user_params)\n respond_to do |format|\n if @user.save\n @user.new_user_registration_email\n format.html { redirect_to login_path, notice: 'User was successfully created. Please see email for Instructions.'\n }\n format.json { render :show, status: :created, location: @user }\n else\n format.html { render :new, notice: 'Fix the errors.'}\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create #sign up button\n @user = User.new(user_params)\n if @user.save\n login(@user)\n redirect_to user_url(@user)\n else\n flash.now[:errors] = @user.errors.full_messages\n render :new\n end\n end",
"def register_user\n user_data = @view.display_registration \n new_user = User.new(user_data[0], user_data[1], user_data[2], user_data[3]) \n access = user_data[2].to_i\n case access\n when 1\n @client.save_info(new_user)\n login_user\n when 2\n @seller.save_info(new_user)\n login_user\n when 10\n @admin.save_info(new_user)\n login_user \n end \n end",
"def create\n if params[:guest]\n @user = User.create(name_family: \"\", name_first: \"\", name_family_kana: \"\", name_first_kana: \"\", phone_number: \"\",\n handle_name: \"guest#{ SecureRandom.random_number(9999) }\",\n user_status: \"guest\",\n password: SecureRandom.alphanumeric(6), confirmed_at: DateTime.now)\n @user.update(email: \"#{ @user.handle_name }@guest.com\")\n sign_in @user\n flash[:notice] = 'ゲスト会員でログインしました。'\n redirect_to root_path\n return\n end\n @user = User.new(sign_up_params)\n render :new and return if params[:back]\n super\n end",
"def new\n case request.method\n when :get\n @user = User.new\n render\n return true\n when :post\n @user = User.new(params[:user])\n begin\n User.transaction(@user) do\n @user.new_password = true\n @user.verified = 1 # skip verification, because we are ADMIN!\n if @user.save\n flash[:notice] = 'User creation successful.'\n redirect_to :action => 'list'\n end\n end\n rescue Exception => e\n flash.now[:notice] = nil\n flash.now[:warning] = 'Error creating account: confirmation email not sent'\n logger.error e\n end\n end\n end",
"def new\n @title = \"Sign up\"\n @user = User.new\n end",
"def new\n\t@title = \"Sign Up\"\n\t@user = User.new\n end",
"def create\n if ( User.find_by_email(params[:user].email) || User.find_by_user_code(params[:user.user_code]) )\n format.html { redirect_to administrators_url, alert: 'Duplicate email or user name detected.' }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n else\n @user = User.new(params[:user])\n\n respond_to do |format|\n if @user.save\n format.html { redirect_to administrators_url, notice: 'User was successfully created.' }\n format.json { render json: administrators_url, status: :created, location: @user }\n else\n format.html { render action: \"new\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def create_user_action\r\n user = User.new\r\n response = user.register_user(params[:username], params[:password], params[:password2])\r\n redirect_to controller: 'user', action: 'user_register', message: response\r\n end",
"def new\n @user = User.new\n @title = \"Sign up\"\n #@action = \"New Action\"\n end",
"def create\n # have name, email, password that person wants to use user_params\n # user model:\n # validate that username is unique (can add in User model)\n # validate against other criteria for user names (can't have a one-letter username, language filter)\n # create obscured version of password with BCrypt::Password.create\n # attempt to save user in database with username, password obscured version of password from the form\n user = User.new(user_params)\n if user.save\n # if user saves properly:\n \t# TODO: redirect to a user created page with instructions for email confirmation\n # log user in\n session[:user_id] = user.id\n \t# redirect to home / success\n redirect_to \"/\"\n else\n # if user does not save:\n \t# flash error message (with specifics!)\n flash[:errors] = user.errors.full_messages.join(\" \")\n \t# redirect to sign up form (/users/new)\n redirect_to signup_path\n end\n\n end",
"def new\n @new_user = User.new\n end",
"def create\n build_resource(configure_sign_up_params)\n resource.save\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n # To avoid login comment out sign_up method\n # sign_up(resource_name, resource)\n respond_to do |format|\n format.json { \n render json: resource # , location: after_sign_up_path_for(resource)\n }\n format.html {respond_with resource, location: after_sign_up_path_for(resource)}\n end\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n respond_to do |format|\n format.json { \n render json: resource # , location: after_inactive_sign_up_path_for(resource)\n }\n format.html {respond_with resource, location: after_inactive_sign_up_path_for(resource)}\n end\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_to do |format|\n format.json { render json: { error_messages: resource.errors.full_messages.join(', ') }, status: 422 }\n format.html {respond_with resource}\n end\n end\n end",
"def create\n cookies.delete :auth_token\n # protects against session fixation attacks, wreaks havoc with \n # request forgery protection.\n # uncomment at your own risk\n # reset_session\n @user = User.new(params[:user])\n @user.save\n \n self.current_user = @user\n \n\trespond_to do |format|\n format.html do\n\tredirect_back_or_default('/')\n\tflash[:notice] = \"Thanks for signing up!\"\n end\n\tformat.xml { render :xml => @user.to_xml }\n end\n \n\trescue ActiveRecord::RecordInvalid\n\t\n\trespond_to do |format|\n format.html { render :action => 'new' }\n format.xml { render :text => \"error\" }\nend\n \n end",
"def new_user_create\n @user = User.create_user(user_params, current_user.account_id) # New User\n begin\n @user.save!\n @users = User.get_all(current_user.account_id)\n flash[:success] = \"User was created successfully!\"\n rescue => e\n flash[:alert] = \"User creation failed!\"\n end \n end",
"def new\n @user = User.new\n enforce_create_permission(@user)\n end",
"def signup!(params)\n self.email = params[:user][:email]\n self.name = params[:user][:name]\n self.password = params[:user][:password]\n #save_without_session_maintenance\n end",
"def new_user\n @user = User.new\n end",
"def create\n build_resource(sign_up_params)\n resource.save\n if resource.persisted?\n if resource.active_for_authentication?\n sign_up(resource_name, resource)\n sign_in(resource_name, resource)\n flash[:notice] = 'Registration Successful.'\n render json: { after_sign_in_path: after_sign_in_path_for(User) }\n else\n expire_data_after_sign_in!\n render json: { error: 'Something went wrong' }, status: 422\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n render json: { error: resource.errors.full_messages.join('<br>') }, status: 422\n end\n end",
"def new\n @title = \"Sign up\"\n @user= User.new\n end",
"def allow_registration?\n true\n end",
"def new \n\t\t@user = User.new\n\tend",
"def register\n\t\ttype = @view.type_client\n\t\t# user_attributes = @view.display_register\n\t\tif type == \"admin\"\n\t\t\tuser_attributes = @view.display_register\n\t\t\tuser = Admin.new(user_attributes[0], user_attributes[1], user_attributes[2])\n\t\t\tuser.add_user(user)\n\t\t\t@current_user = user\n\t\t\toption = @view.second_view(user, user.actions)\n\t\t\tlist(option)\n\t\telsif type == \"vendor\"\n\t\t\tuser_attributes = @view.display_register\n\t\t\tuser = Vendor.new(user_attributes[0], user_attributes[1], user_attributes[2])\n\t\t\tuser.add_user(user)\n\t\t\t@current_user = user\n\t\t\toption = @view.second_view(user, user.actions)\n\t\t\tlist(option)\n\t\telsif type == \"client\"\n\t\t\tuser_attributes = @view.display_register\n\t\t\tuser = Client.new(user_attributes[0], user_attributes[1], user_attributes[2])\n\t\t\tuser.add_user(user)\n\t\t\t@current_user = user\n\t\t\toption = @view.second_view(user, user.actions)\n\t\t\tlist(option)\n\t\telse\n\t\t \tputs \"Try again\"\n\t\t \tputs \"\"\n\t\t \toption = @view.initial_view\n\t\t \tselect(option)\n\t\tend\n\tend",
"def create\n @user = User.new user_params #authenticating the user's information. fill in the db with these values.\n if @user.save #if it saves,\n redirect_to \"/users/#{ @user.id }\" #redirect to their profile page\n else\n render :new #if not new form.\n end\n end",
"def create\n @user = User.new(member_params)\n restrict_other_family\n @user.username = (0...4).map{ ('a'..'z').to_a[rand(26)] }.join\n\n respond_to do |format|\n if @user.save\n # redirect_back_or_default new_user_url\n\n format.html { redirect_to member_path(@user), notice: \"#{@user.dispname(User::FULLNAME)}を登録しました.\" }\n format.json { render json: @user, status: :created, location: @user }\n else\n @users = User.includes_ext.order(\"user_exts.birth_day ASC\")\n format.html { render action: \"new\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @user = User.new\n @is_signup = true\n end",
"def create\n\n #.create is a method we get from AR.\n #it returns a new object in local memory with the specified params\n #it then saves the hash object in the database.\n @user = User.create user_params\n if @user.save\n session[:user_id] = @user.id.to_s\n flash['alert-success'] = \"You have been registered #{@user.username}, please login.\"\n redirect_to new_session_path\n else\n flash['alert-warning'] = 'Unable to create a user account.'\n redirect_to new_user_path\n end\n end",
"def create\n user = User.new(sign_up_params)\n user.save!\n\n # Check if active for authentication.\n # If it needs mail confirmation, etc.., return false.\n if resource.active_for_authentication?\n # Validate params for authorize.\n if pre_auth.authorizable?\n # TODO: Fase 2, activate below flow.\n # if skip_authorization? || matching_token?\n # auth = authorization.authorize\n # redirect_to auth.redirect_uri\n # else\n # render :new\n # end\n\n # TODO: Fase 2, remove below process.\n result = authorization.authorize\n render json: result.auth, status: 201\n else\n # TODO: Fase 2, return error view.\n render json: pre_auth.error_response.body, status: 400\n end\n else\n render json: \"mail okuttayo\", status: 201\n end\n end",
"def create\n # Modified the super class to allow for ip address on sign_up\n build_resource(sign_up_params)\n resource.sign_up_ip = request.env['REMOTE_ADDR']\n resource.save\n yield resource if block_given?\n if resource.persisted?\n if resource.active_for_authentication?\n set_flash_message! :notice, :signed_up\n sign_up(resource_name, resource)\n respond_with resource, location: after_sign_up_path_for(resource)\n else\n set_flash_message! :notice, :\"signed_up_but_#{resource.inactive_message}\"\n expire_data_after_sign_in!\n respond_with resource, location: after_inactive_sign_up_path_for(resource)\n end\n else\n clean_up_passwords resource\n set_minimum_password_length\n respond_with resource\n end\n\n if @teacher.persisted?\n @teacher.submit_signup\n end\n cookies[:is_signed_in] = teacher_signed_in?\n cookies[:signed_in_type] = 'teacher'\n if teacher_signed_in?\n cookies[:name] = current_teacher.first_name\n end\n end",
"def make_user\n end",
"def sign_up(resource_name, resource)\n true\n end",
"def create\n @user = User.new(user_params)\n\n \n\n respond_to do |format|\n if @user.save\n\n #if a normal user is signing up, send a confirmation email\n if (!current_user || [email protected])\n UserNotifier.send_signup_email(@user).deliver!\n if (!current_user)\n format.html { render :confirmation_process } \n end\n end\n\n\n\n format.html { redirect_to @user, notice: 'User was successfully created.' }\n format.json { render :show, status: :created, location: @user }\n else\n format.html { render :new }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.73073465",
"0.7286683",
"0.7195135",
"0.7118714",
"0.70851284",
"0.7084818",
"0.7028504",
"0.7018612",
"0.6981577",
"0.6922201",
"0.69186085",
"0.6916251",
"0.68766665",
"0.68730956",
"0.68713564",
"0.68543804",
"0.6848034",
"0.6845089",
"0.6838803",
"0.682362",
"0.6819858",
"0.68123364",
"0.6810385",
"0.6801393",
"0.6792395",
"0.6784414",
"0.6767198",
"0.6762619",
"0.67578405",
"0.67577946",
"0.6746876",
"0.6744507",
"0.6743264",
"0.6735602",
"0.67333955",
"0.6721737",
"0.67154336",
"0.6710287",
"0.6706947",
"0.6697679",
"0.6697468",
"0.6696774",
"0.6673916",
"0.6673916",
"0.66728985",
"0.66533124",
"0.6651644",
"0.66493",
"0.6640717",
"0.66341054",
"0.66287136",
"0.6621801",
"0.6619404",
"0.6617972",
"0.66175556",
"0.6615693",
"0.6615161",
"0.6611406",
"0.66013813",
"0.66008717",
"0.6598023",
"0.65900093",
"0.6586637",
"0.65852875",
"0.6578545",
"0.65688676",
"0.65657103",
"0.6558185",
"0.6555136",
"0.6552727",
"0.6550768",
"0.6550564",
"0.65448815",
"0.6543156",
"0.65398574",
"0.65324837",
"0.6532292",
"0.65216184",
"0.6517968",
"0.6515617",
"0.6506279",
"0.6497204",
"0.649569",
"0.6489898",
"0.64887035",
"0.648845",
"0.6487685",
"0.64843285",
"0.6479847",
"0.6464697",
"0.646309",
"0.64608693",
"0.64607894",
"0.64541054",
"0.64537704",
"0.6450606",
"0.64498484",
"0.6448786",
"0.6445253",
"0.6445123",
"0.64412904"
] | 0.0 | -1 |
Padrino's asset handling needs to pass through ours | def asset_path(kind, source)
return source if source =~ /^http/
asset_folder = case kind
when :css then settings.css_dir
when :js then settings.js_dir
when :images then settings.images_dir
else kind.to_s
end
source = source.to_s.gsub(/\s/, '')
ignore_extension = (kind == :images) # don't append extension
source << ".#{kind}" unless ignore_extension or source =~ /\.#{kind}/
result_path = source if source =~ %r{^/} # absolute path
result_path ||= asset_url(source, asset_folder)
timestamp = asset_timestamp(result_path)
"#{result_path}#{timestamp}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resolve_asset; end",
"def resolve_asset; end",
"def assets; end",
"def assets; end",
"def assets; end",
"def asset_file?; end",
"def asset_file?; end",
"def asset_host; end",
"def asset_host; end",
"def assets=(_arg0); end",
"def assets=(_arg0); end",
"def assets=(_arg0); end",
"def asset_host=(_arg0); end",
"def asset_host=(_arg0); end",
"def asset_resolver_strategies; end",
"def asset_resolver_strategies; end",
"def assets_manifest; end",
"def assets_manifest; end",
"def render_assets request, response, params\n\t\t\t\t# contine only if assets are defined and called for\n\t\t\t\treturn false unless params[:assets] && (request.path =~ params[:assets_public_regex])\n\t\t\t\t# review callback, if defined\n\t\t\t\treturn true if params[:assets_callback] && params[:assets_callback].call(request, response)\n\n\t\t\t\t# get file requested\n\t\t\t\tsource_file = File.join(params[:assets], *(request.path[params[:assets_public_length]..-1].split('/')))\n\n\n\t\t\t\t# stop if file name is reserved / has security issues\n\t\t\t\treturn false if File.directory?(source_file) || source_file =~ params[:assets_refuse_templates]\n\n\t\t\t\t# set where to store the rendered asset\n\t\t\t\ttarget_file = File.join( params[:public].to_s, *request.path.split('/') )\n\n\t\t\t\t# send the file if it exists (no render needed)\n\t\t\t\tif File.exists?(source_file)\n\t\t\t\t\tdata = if ::Plezi::Cache::CACHABLE.include?(::File.extname(source_file)[1..-1])\n\t\t\t\t\t\tPlezi.cache_needs_update?(source_file) ? Plezi.save_file(target_file, Plezi.reload_file(source_file), (params[:public] && params[:save_assets])) : Plezi.load_file(source_file)\n\t\t\t\t\telse\n\t\t\t\t\t\t::File.new source_file, 'rb'\n\t\t\t\t\tend\n\t\t\t\t\treturn (data ? Base::HTTPSender.send_raw_data(request, response, data, MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)]) : false)\n\t\t\t\tend\n\n\t\t\t\t# render the file if it's a registered asset\n\t\t\t\tdata = ::Plezi::AssetManager.render source_file, binding\n\t\t\t\tif data\n\t\t\t\t\treturn ::Plezi::Base::HTTPSender.send_raw_data request, response, Plezi.save_file(target_file, data, (params[:public] && params[:save_assets])), MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)]\n\t\t\t\tend\n\n\t\t\t\t# send the data if it's a cached asset (map files and similar assets that were cached while rendering)\n\t\t\t\tif Plezi.cached?(source_file)\n\t\t\t\t\treturn Base::HTTPSender.send_raw_data(request, response, Plezi.get_cached(source_file), MimeTypeHelper::MIME_DICTIONARY[::File.extname(source_file)])\n\t\t\t\tend\n\n\t\t\t\t# return false if an asset couldn't be rendered and wasn't found.\n\t\t\t\treturn false\n\t\t\tend",
"def copy_assets; end",
"def before_create\n if self.asset.nil? && self.viewable\n self.asset = self.viewable.asset if self.viewable.respond_to? :asset\n end\n end",
"def create\n @asset = OtherAsset.new(params[:asset])\n asset_create('other', others_url)\n end",
"def precompile_assets; end",
"def build_assets\n end",
"def create\n @bes_asset = BesAsset.new(bes_asset_params)\n fix_questions()\n respond_to do |format|\n if @bes_asset.save\n @bes_asset.proof.url # => '/url/to/file.png'\n @bes_asset.proof.current_path # => 'path/to/file.png'\n @bes_asset.proof_identifier # => 'file.png'\n\n\n format.html { redirect_to @bes_asset, notice: 'Asset was successfully created!' }\n format.json { render :show, status: :created, location: @bes_asset }\n else\n format.html { render :new }\n format.json { render json: @bes_asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def request_debug_assets?; end",
"def request_debug_assets?; end",
"def asset_url(asset_name)\n \"#{@server.base_uri}?sabreAction=asset&assetName=#{URI.escape(asset_name)}\"\n end",
"def get_asset(*params); raise('Stub or mock required.') end",
"def asset_class\n raise NotImplementedError\n end",
"def assets\n []\n end",
"def collins_asset\n @host.collins_asset\n end",
"def create\n @asset = Asset.new(params[:asset])\n \n if @asset.save\n @asset = Asset.find(@asset.id)\n @asset.update_attributes(params[:asset])\n \n if @asset.asset_content_type.include? \"image\"\n respond_to do |format|\n format.html { render }\n format.js { \n responds_to_parent do\n render :update do |page|\n page.insert_html :top, \"assets_list\", :partial => 'admin/galleries/assets/excerpt', :locals => { :excerpt => @asset }\n page.call('gallery.AssetCreate');\n end\n end\n } \n format.xml { render :xml => @asset.to_xml(attr_hash) }\n format.json { render :json => @asset.to_json(attr_hash) }\n end\n else\n respond_to do |format|\n @message = t('asset_must_be_image')\n format.html { \n flash[:error] = @message\n render\n }\n format.js { render :text => @asset.errors.to_json, :status => :unprocessable_entity }\n format.json { render :json => {:message => @message}, :status => :unprocessable_entity }\n format.xml { render :xml => {:message => @message}, :status => :unprocessable_entity }\n end\n end\n else\n respond_to do |format|\n @message = t('asset_create_failed')\n format.html { \n flash[:error] = @message\n render\n }\n format.js { render :text => @asset.errors.to_json, :status => :unprocessable_entity }\n format.json { render :json => {:message => @message}, :status => :unprocessable_entity }\n format.xml { render :xml => {:message => @message}, :status => :unprocessable_entity }\n end\n end\n \n end",
"def precompile_assets=(_arg0); end",
"def route_for_manufacturing\n Core.log(\"ROUTE FOR MANUFACTURING\")\n if self.orderable_type != \"NonCustomizableProduct\"\n self.delay(:queue => \"assets\").attach_asset_and_enqueue\n end\n end",
"def create\n @user_asset = UserAsset.new(params[:user_asset])\n @user_asset.user_id = current_user.id\n @commit = params[:commit]\n @user_asset.guid = generate_guid\n\n respond_to do |format|\n # if @controller == \"UserAssetsController\"\n if @user_asset.save\n if @user_asset.asset_type != \"weblink\"\n @user_asset.extract_uploaded_zip\n @launch_file_status = set_launch_file\n @user_asset.encrypt_and_zip unless @launch_file_status\n end\n # if !@launch_file_status\n # @user_asset.delay.encrypt_files\n # end\n\n format.html { redirect_to \"/user_assets\", notice: 'User asset was successfully created.' }\n format.json { render json: @user_asset, status: :created, location: @user_asset }\n format.js\n else\n format.html { render action: \"new\" }\n format.json { render json: @user_asset.errors, status: :unprocessable_entity }\n format.js { render 'errors'}\n end\n\n end\n end",
"def create\n @asset = Asset.new(asset_params)\n @asset_owner = User.all\n @category = Category.all\n if @asset.save\n if [email protected]?\n render :js => \"window.location = '/site_assets'\"\n else\n redirect_to assets_path, notice: 'Asset was successfully created.'\n end\n else\n render 'create_failure'\n end\n end",
"def asset_path\n \"user/#{self.user_id}/assets/\"\n end",
"def load_asset\n @asset = Asset.accessible_by(current_ability).find(params[:id])\n end",
"def local_asset\n downloader_script = ::File.join(Opsworks::InstanceAgent::Environment.default_cookbooks_path, '../bin/downloader.sh')\n download_basedir = Opsworks::InstanceAgent::Environment.file_cache_path.empty? ? '/tmp/opsworks_assets' : \"#{Opsworks::InstanceAgent::Environment.file_cache_path}/opsworks_assets\"\n\n asset_basedir = \"#{download_basedir}/#{@new_resource.asset}\"\n ::FileUtils.mkdir_p asset_basedir\n\n cmd = Mixlib::ShellOut.new(\"#{downloader_script} -r #{@new_resource.max_fetch_retries} -u #{asset_url} -d '#{asset_basedir}'\")\n cmd.run_command\n local_asset_path = cmd.stdout.chomp\n STDERR.puts cmd.stderr\n\n if !cmd.error? &&\n ::File.file?(local_asset_path) &&\n ::File.fnmatch(\"#{asset_basedir}.*\", ::File.dirname(local_asset_path))\n\n yield(local_asset_path)\n\n # remove all downloaded file for this asset, also failed attemps.\n ::FileUtils.rm_rf(Dir[\"#{asset_basedir}.*\"], :verbose => true) rescue Chef::Log.error \"Couldn't cleanup downloaded assets for #{@new_resource.name}.\"\n elsif @new_resource.ignore_failure\n Chef::Log.error \"Failed to download asset #{asset_name} for #{@new_resource.name} with url #{asset_url}.\"\n else\n msg = [\"Failed to download asset #{@new_resource.asset} for #{@new_resource.name} with url #{asset_url}.\"]\n\n if cmd.stderr.include?(\"403 Forbidden\")\n msg << \"The asset is probably not available for your operating system (#{node[:platform]} #{node[:platform_version]}).\"\n msg << \"Please have a look what versions are supported for this operating system at:\"\n msg << \"http://docs.aws.amazon.com/opsworks/latest/userguide/workinginstances-os-linux.html\"\n end\n fail Chef::Exceptions::ResourceNotFound, msg.join(\"\\n\")\n end\nend",
"def local_asset\n downloader_script = ::File.join(Opsworks::InstanceAgent::Environment.default_cookbooks_path, '../bin/downloader.sh')\n download_basedir = Opsworks::InstanceAgent::Environment.file_cache_path.empty? ? '/tmp/opsworks_assets' : \"#{Opsworks::InstanceAgent::Environment.file_cache_path}/opsworks_assets\"\n\n asset_basedir = \"#{download_basedir}/#{@new_resource.asset}\"\n ::FileUtils.mkdir_p asset_basedir\n\n local_asset_path = `#{downloader_script} -r #{@new_resource.max_fetch_retries} -u #{asset_url} -d \"#{asset_basedir}\"`.chomp\n\n if $?.success? &&\n ::File.file?(local_asset_path) &&\n ::File.fnmatch(\"#{asset_basedir}.*\", ::File.dirname(local_asset_path))\n\n yield(local_asset_path)\n\n # remove all downloaded file for this asset, also failed attemps.\n ::FileUtils.rm_rf(Dir[\"#{asset_basedir}.*\"], :verbose => true) rescue Chef::Log.error \"Couldn't cleanup downloaded assets for #{@new_resource.name}.\"\n elsif @new_resource.ignore_failure\n Chef::Log.error \"Failed to download asset #{asset_name} for #{@new_resource.name}.\"\n elsif !@new_resource.ignore_failure\n raise Chef::Exceptions::ResourceNotFound, \"Failed to download asset #{@new_resource.asset} for #{@new_resource.name}.\"\n end\nend",
"def assets_manifest=(_arg0); end",
"def assets_manifest=(_arg0); end",
"def attach_asset_and_enqueue\n\n Core.log(\"============= RETRIEVING ASSET FOR ##{self.id}\")\n begin\n design_url = URI.parse(self.asset_url)\n rand_id = rand(999999).to_s\n tempfile = \"#{Rails.root}/tmp/\" + rand_id + '.jpg'\n error_file = \"#{Rails.root}/tmp/#{self.product.id}-#{self.id}-#{self.order.id}-error\" + '.jpg'\n Core.log(\"********** Creating Tempfile #{tempfile} **************\")\n tries = 0\n\n begin\n http = Net::HTTP.new(design_url.host, design_url.port)\n use_ssl = (design_url.port == 443) ? true : false\n http.use_ssl = use_ssl\n http.open_timeout = 15\n http.read_timeout = 30\n \n if design_url.query.blank?\n path = design_url.path\n else\n path = design_url.path + \"?\" + design_url.query\n end\n \n Core.log(\"*********** Image URL: #{self.asset_url} ****************\")\n request = Net::HTTP::Get.new(path)\n response = http.request(request)\n \n if response.kind_of?(Net::HTTPRedirection)\n Core.log \"============= WE GOT REDIRECTED! =====================\"\n design_url = URI.parse(response['location'])\n Core.log(\"*********** Image URL: #{design_url} ****************\")\n raise \"WE_GOT_REDIRECTED\"\n end\n\n Core.log(\"============= HTTP response code: #{response.code.inspect}, HTTP message: #{response.message.inspect}\")\n open(tempfile, \"wb\") {|file| file.write(response.body)}\n\n rescue\n Core.log(\"============= In the rescue HTTP response: #{response.inspect}\")\n tries += 1\n Core.log(\"============= RETRY NUMBER #{tries.to_s}: ASSET RETRIEVAL FOR ##{self.id}\")\n retry if tries < 3\n Core.log(\"============= RETRY: giving up on ASSET RETRIEVAL FOR ##{self.id}\")\n Core.log(\"*************** Deleting Tempfile #{tempfile} ******************\")\n File.delete(tempfile)\n end\n\n File.open(tempfile, 'rb') { |design| self.asset = design }\n asset_width = Paperclip::Geometry.from_file(tempfile).width.to_i\n asset_height = Paperclip::Geometry.from_file(tempfile).height.to_i\n\n self.asset_dimensions = \"#{asset_width}x#{asset_height}\"\n self.save\n\n=begin\n if self.order.source.name.upcase == \"SHUTTERFLY\" || self.order.source.shutterfly_partner\n file_type = %x[identify -format '%m' \"#{tempfile}\"].gsub!(\"\\n\", \"\")\n if file_type == \"PDF\"\n #save a copy for jessa's color comparisons\n target = \"#{Rails.root}/public/assets/uploaded_pdfs/\" + self.order.id.to_s + \"-\" + self.id.to_s + \"-original.pdf\"\n Core.log(\"*************** Copying Tempfile #{tempfile} to uploaded_pdf file #{target}******************\")\n FileUtils.cp(tempfile, target)\n end\n end\n=end\n\n\n Core.log(\"*************** Deleting Tempfile #{tempfile} ******************\")\n File.delete(tempfile)\n\n # Drop the attached asset in the queue to generate manufacturable assets.\n Core.enqueue(self)\n\n rescue Exception => e\n #don't move this line below self.update_attribute...causes self to change to a different object\n self.order.set_status('Asset Error(s)')\n Rails.logger.info \"\\n\\n****=====***** image upload failed with this error: #{e.inspect} ****=====*****\\n\\n\"\n Core.log(\"============= ERROR RETRIEVING ASSET FOR ##{self.id}\")\n OrderStatus.create(:order_id => order.id, :status => \"Error fetching asset ##{id}\")\n self.update_attribute(:asset_errors, true)\n Core.log(\"*************** Renaming Tempfile #{tempfile} => #{error_file} ******************\")\n File.rename(tempfile,error_file)\n end\n\n end",
"def get\n # first find the asset within own assets\n asset = current_user.assets.find_by_id(params[:id])\n\n # if not found in own assets, check if the current_user has share access to the parent folder of the file\n asset ||= Asset.find(params[:id]) if current_user.has_share_access?(Asset.find_by_id(params[:id]).folder)\n\n if asset\n # Parse the URL for special characters first before downloading\n data = open(asset.s3_url)\n \n # use the send_data method to send the above bindary \"data\" as a file\n send_data data, :filename => asset.file_name\n\n #redirect to amazon S3 url which will let the user download the file automatically \n # redirect_to asset.uploaded_file.url, :type => asset.uploaded_file_content_type\n else\n flash[:error] = \"Don't be cheeky! Mind your own assets!\" + \":Rails_ROOT/config/amazon_s3.yml\"\n redirect_to assets_path\n end\n end",
"def assets\n \n if !params[:path].blank? or !params[:format].blank?\n if get_from_asset_folder\n return\n else\n render_404 and return\n end\n end\n end",
"def get \n asset = current_user.assets.find_by_id(params[:id]) \n if asset \n send_file asset.upload_file.path, :type => asset.upload_file_content_type \n else \n flash[:notice] = \"Don't be cheeky! Mind your own assets!\" \n redirect_to assets_path ,flash: { notice: \"Don't be cheeky! Mind your own assets!\" }\n end \n end",
"def create\n @asset = @uploadable.assets.new(asset_params)\n if request.path.include? \"rooms\"\n if @asset.save\n redirect_to venue_rooms_path\n else\n render :new\n end\n else\n if @asset.save\n redirect_to @uploadable, notice: \"asset created.\"\n else\n render :new\n end\n end\n end",
"def create\n @global_asset = GlobalAsset.new(global_asset_params)\n \n upload_hash = FileUploadUtil.uploadFile(params[:data_file], \"global_asset\", ['rar','pdf','word','zip','txt','sql'])\n if upload_hash[:status] == 'error'\n respond_to do |format|\n flash[:notice] = upload_hash[:msg]\n format.html { render action: \"new\" }\n format.json { render json: @global_asset.errors, status: :unprocessable_entity }\n end\n return\n end\n if !params[:data_file].nil?\n @global_asset.data_file_url = upload_hash[:file_name]\n @global_asset.data_content_type = upload_hash[:content_type]\n @global_asset.data_file_size = upload_hash[:file_size]\n @global_asset.width = upload_hash[:width]\n @global_asset.height = upload_hash[:height]\n @global_asset.user_id = @current_user.uid\n @global_asset.user_name = @current_user.name\n end\n \n respond_to do |format|\n if @global_asset.save\n format.html { redirect_to admin_global_asset_path(@global_asset), notice: 'Global asset was successfully created.' }\n format.json { render json: @global_asset, status: :created, location: @global_asset }\n else\n format.html { render action: \"new\" }\n format.json { render json: @global_asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def assets_path() = self.class.name.demodulize.delete_suffix('Generator').underscore",
"def asset_handler\n tags = String.new\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/icons.css\")\n if controller_name == \"rich_subscriptions\"\n tags << content_tag(:script, \"\", src: \"/javascripts/#{fingerprinted_asset('map')}.js\")\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/leaflet/leaflet.css\")\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/leaflet/leaflet-slider.css\")\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/leaflet/L.Control.Locate.min.css\")\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/#{fingerprinted_asset('map')}.css\")\n else\n tags << content_tag(:script, \"\", src: \"/javascripts/#{fingerprinted_asset('application')}.js\")\n tags << tag(:link, rel: \"stylesheet\", href: \"/stylesheets/#{fingerprinted_asset('application')}.css\")\n end\n tags.html_safe\n end",
"def create\n @asset = Asset.new(params[:asset])\n\n respond_to do |format|\n if @asset.save\n flash[:notice] = 'Asset was successfully created.'\n format.html { redirect_to(admin_assets_url) }\n format.xml { render :xml => @asset, :status => :created, :location => admin_asset_url(@asset) }\n format.js { render :json => @asset, :status => 200, :location => admin_asset_url(@asset) }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @asset.errors, :status => :unprocessable_entity }\n format.js { render :json => @asset.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n repo = assets_repo\n\n file = (params.has_key?(:file)) ? params[:file] : false\n @v_asset = repo.create file\n\n respond_to do |format|\n if @v_asset.save\n format.html { redirect_to @v_asset, notice: 'V asset was successfully created.' }\n format.json { render json: @v_asset, status: :created, location: @v_asset }\n else\n format.html { render action: \"new\" }\n format.json { render json: @v_asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n if request.format == :xml\n super\n else\n passed_values = params[:asset]\n @asset = Asset.create(\n :g_u_i_d => passed_values[:g_u_i_d],\n :tag => passed_values[:tag],\n :name => passed_values[:name],\n :i_d_in_info_source => passed_values[:i_d_in_info_source],\n :status => \"1\",\n :model => Model.find_by_guid(passed_values[:model]),\n :manufacturer => Manufacturer.find_by_guid(passed_values[:manufacturer]),\n :serial_number => passed_values[:serial_number])\n Notification.create(\n :message => \"Created an Asset via HTML CRUD utility (create Asset form)\", \n :operation => \"Create\",\n :ccom_entity => @asset.guid,\n :about_user => User.find_by_id(session[:user_id]),\n :database => ActiveRegistry.find_database(session[:user_id])\n ) \n if object_type = ObjectType.find_by_guid(passed_values[:object_type])\n @asset.update_attributes(:object_type => object_type)\n else\n @asset.update_attributes(:object_type => ObjectType.undetermined)\n end\n \n ref_valid_network = ValidNetwork.find_by_guid(passed_values[:valid_network])\n valid_network = ref_valid_network.nil? ? nil : ref_valid_network.dup_entity(:gen_new_guids => true)\n @asset.update_attributes( :valid_network => valid_network)\n\n respond_to do |format|\n if @asset.save\n flash[:notice] = \"Asset was saved into database at #{@asset.last_edited}\"\n format.html { redirect_to(@asset) }\n else\n @types = get_all_asset(:object_type)\n @manufacturers = get_all_asset(:manufacturer)\n @models = get_all_asset(:model)\n @networks = define_networks()\n format.html { render :action => \"new\" }\n end\n end\n end\n end",
"def show\n @asset = Asset.find(params[:id])\n response.headers['X-Accel-Redirect'] = @asset.asset.url\n response.headers[\"Content-Type\"] = @asset.asset_content_type\n response.headers['Content-Disposition'] = \"attachment; filename=#{@asset.asset_file_name}\" \n response.headers['Content-Length'] = @asset.asset_file_size\n render :nothing => true\n end",
"def set_assets\n\n @custom_csses = []\n @custom_javascripts = []\n\n\n action_hash = {\"create\" => \"new\", \"update\" => \"edit\"}\n file_name = action_hash[action_name] ? action_hash[action_name] : action_name\n root = Rails.root.to_s\n\n @custom_csses << \"compiled/application.css\" # always include the layout css\n @custom_csses << \"compiled/#{controller_name}/#{file_name}.css\" if File.exist?(\"#{root}/public/stylesheets/compiled/#{controller_name}/#{file_name}.css\")\n @custom_csses << \"compiled/#{controller_name}/all.css\" if File.exist?(\"#{root}/public/stylesheets/compiled/#{controller_name}/all.css\")\n\n\n @custom_javascripts << \"#{controller_name}/#{file_name}.js\" if File.exist?(\"#{root}/public/javascripts/#{controller_name}/#{file_name}.js\") # && !(\"#{file_name}.js\" == \"consumer_index.js\")\n @custom_javascripts << \"#{controller_name}/all.js\" if File.exist?(\"#{root}/public/javascripts/#{controller_name}/all.js\")\n\n # a trick to include facebox in the (devise-owned) registrations controller\n include_facebox if controller_name == 'registrations' && action_name == 'edit'\n\n end",
"def show\n repo = assets_repo\n @v_asset = repo.get(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @v_asset }\n end\n end",
"def asset_map\n raise NotImplementedError\n end",
"def path\n asset_source_path\n end",
"def path\n asset_source_path\n end",
"def create\n @clicker = Clicker.find_or_create_by_address(request.remote_ip)\n @clicker.clicks = @clicker.clicks.nil? ? 0 : (@clicker.clicks+1).to_i\n\n @asset = Asset.find(params[:asset_id])\n @asset.assetable_id = @asset.assetable_id.nil? ? 0 : (@asset.assetable_id+1).to_i\n @asset.save\n\n respond_to do |format|\n if @clicker.save\n format.js \n format.json { render json: @clicker, status: :created, location: @clicker }\n else\n format.html { render action: \"new\" }\n format.json { render json: @clicker.errors, status: :unprocessable_entity }\n end\n end\n end",
"def asset_base_uri\n \"/#{File.basename(Engines.public_dir)}/#{name}\"\n end",
"def asset path\n @app.asset path\n end",
"def set_asset\n @asset = @org.assets.find(params[:id])\n end",
"def handle_asset_housekeeper_ids\n handle_admin_role_ids Seek::Roles::ASSET_HOUSEKEEPER\n end",
"def handle_asset_housekeeper_ids\n handle_admin_role_ids Seek::Roles::ASSET_HOUSEKEEPER\n end",
"def production_opening\n @images_path = \"/../../assets/images\"\n end",
"def find_asset(asset_name) # , views)\n search_path = proc do |path| \n full_path = path + asset_name\n return full_path if File.exist?(full_path)\n end \n check_meta(@meta, \"find_asset\")\n views = @meta.views\n views.each do |view| search_path.call(\"#{view.dir}/#{@meta.slug}/assets/\") end\n views.each do |view| search_path.call(view.dir + \"/assets/\") end\n search_path.call(@root + \"/assets/\", asset_name)\n # If all fail... return nil\n return nil\n end",
"def getLogoData(data)\n data && data['asset_id'] && data['width'] && data['height'] or return nil\n return { url: \"/assets/#{data['asset_id']}\", width: data['width'], height: data['height'] }\nend",
"def access_dir\n \"/assets/#{model.imageable_type.downcase.pluralize}/\"\n end",
"def create\n @asset = Asset.new(params[:asset])\n\n respond_to do |format|\n if @asset.save\n flash[:notice] = 'Asset was successfully created.'\n format.html { redirect_to asset_url(@asset) } \n format.js # render create.rjs << added for P/C >>\n format.xml { head :created, :location => asset_url(@asset) }\n else\n format.html { render :action => \"new\" }\n format.js # render create.rjs << added for P/C >>\n format.xml { render :xml => @asset.errors.to_xml }\n end\n end\n end",
"def create_asset_and_respond(item)\n item = create_asset(item)\n if item.save\n unless return_to_fancy_parent(item)\n flash[:notice] = \"#{t(item.class.name.underscore)} was successfully uploaded and saved.\"\n respond_to do |format|\n format.html { redirect_to params[:single_page] ?\n { controller: :single_pages, action: :show, id: params[:single_page] } \n : item }\n format.json { render json: item, include: json_api_include_param }\n end\n end\n else\n respond_to do |format|\n format.html { render action: 'new' }\n format.json { render json: json_api_errors(item), status: :unprocessable_entity }\n end\n end\n end",
"def target_asset_path(asset)\n File.join('public', asset.folder, asset.filename)\n end",
"def asset_url(source, options = T.unsafe(nil)); end",
"def update_asset_settings!\n AssetSettings[:development].files[@file_id] = @sfiles.map(&:local_url)\n return unless AssetMapper.compile?\n\n AssetSettings[:production].files[@file_id] = @cloud_files.map(&:production_url)\n AssetSettings[:production].files[@file_id] << @tfile.production_url if @tfile.production_url\n\n AssetSettings[:local_assets].files[@file_id] = @cloud_files.map(&:local_url)\n AssetSettings[:local_assets][@file_id] << @tfile.local_url if @tfile.local_url\n end",
"def assets_under_embargo\n @assets_under_embargo ||= EtdEmbargoService.assets_under_embargo\n end",
"def update\n @asset = OtherAsset.find(params[:id])\n asset_update(params[:asset], others_url)\n end",
"def assets\n\n javascript={}\n css={}\n\n Dir.glob(bower_asset_path+'/production/*.html').each { |path|\n next if files_omit.include?(File.basename(path))\n page = Nokogiri::HTML(open(path))\n javascript[path]=[]\n css[path]=[]\n page.css('script').each { |st|\n javascript[path] << st.attr('src').sub('../vendors/', '') if st.attr('src') && st.attr('src').start_with?('../')\n }\n page.css('link').each { |st|\n css[path] << st.attr('href').sub('../vendors/', '') if st.attr('rel') && st.attr('rel') == 'stylesheet'\n }\n }\n\n# Merge the lists of script and css references using array union\n javascript_src=[]\n javascript.values.map { |s| javascript_src = javascript_src | s }\n javascript_src.uniq!\n\n# Omit the references that we won't include in the gem\n javascript_omit.each { |s| javascript_src.delete(s) }\n\n css_src=[]\n css.values.map { |s| css_src = css_src | s }\n css_src.uniq!\n\n css_omit.each { |s| css_src.delete(s) }\n\n {\n javascript: javascript_src,\n css: css_src,\n }\n\nend",
"def set_asset\n @asset = Asset.find(params[:id])\n end",
"def ckeditor_before_create_asset(asset)\n asset.assetable = current_account\n return true\n end",
"def show\n #@assets = @project.assets.all\n\n end",
"def _assets path, domain = '/'\n\t\t\"#{domain}_assets/#{path}\"\n\tend",
"def create\n @asset = Asset.new(params[:asset])\n respond_to do |format|\n if @asset.save\n format.html { redirect_to(\"/admin/posts/#{@asset.post_id}\", :notice => 'Gravado com Sucesso') } \n else\n format.html { render :action => \"new\" }\n end\n end\n end",
"def compute_asset_host(source = T.unsafe(nil), options = T.unsafe(nil)); end",
"def asset_integrate\n \tputs \"<===================create snippet=================>\"\n \tShopifyAPI::Base.site = \"https://#{ShopifyApp.configuration.api_key}:#{self.shopify_token}@#{self.shopify_domain}/admin/\"\n ShopifyAPI::Base.api_version = ShopifyApp.configuration.api_version\n @theme = ShopifyAPI::Theme.find(:all).where(role: 'main').first\n @asset = ShopifyAPI::Asset.create(key: 'snippets/better-cart.liquid', value: \"\n <script>\n window.betterCart = {\n shopify_domain: '{{shop.permanent_domain}}',\n app_url: '#{ENV['DOMAIN']}',\n cart_total: 0\n }\n window.betterCart.cart_total = {{ cart.total_price }}\n console.log(window.betterCart.cart)\n $( \\\"a[href='/cart']\\\" ).each(function( index ) {\n height = $( this ).height();\n b_class=$( this ).attr('class');\n {% if cart.item_count > 0 %}\n \tcart_image = 'cart.gif'\n {% else %}\n \tcart_image = 'cart.svg'\n {% endif %}\n \t\t\t$( this ).replaceWith(\\\"<a href='/cart' class='\\\"+b_class+\\\"'><img src='#{ENV['DOMAIN']}/\\\"+cart_image+\\\"' alt='cart' style='height:\\\"+height+\\\"px;'></a>\\\")\n\t\t\t\t});\n </script>\n\n \", theme_id: @theme.id) rescue nil\n\n @asset = ShopifyAPI::Asset.find('layout/theme.liquid', :params => { :theme_id => @theme.id}) rescue nil\n if @asset.present?\n @asset_value = @asset.value\n @asset.update_attributes(theme_id: @theme.id,value: @asset_value.gsub(\"</body>\",\"{% comment %}This is from betterCart.{% endcomment %}{% include 'better-cart' %}</body>\")) unless @asset_value.include?(\"{% include 'better-cart' %}\")\n end\n end",
"def asset_params\n params.require(:asset).permit()\n end",
"def asset_name\n 'Playlist'\n end",
"def set_asset\n @asset = @user.assets.find(params[:id])\n end",
"def create\n @asset = Asset.new(params[:asset])\n @home = Home.find(params[:home_id])\n @asset.home = @home\n \n respond_to do |format|\n if @asset.save\n flash[:notice] = 'Asset was successfully created.'\n # Expire the caches for main and thumb asset and delete if old asset present\n if (@home.asset)\n expire_page(asset_type_path(@home.asset, false)) # main\n expire_page(asset_type_path(@home.asset, true)) # thumb\n # Deleting the main asset internally deletes thumbnails in attachment_fu\n Asset.delete(@home.asset_id)\n end\n @home.asset = @asset # link home to new photo\n @home.save\n format.html { redirect_to(@home) }\n format.xml { render :xml => @asset, :status => :created, :location => @asset }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @asset.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def resolve_asset_path(path, allow_non_precompiled = T.unsafe(nil)); end",
"def resolve_asset_path(path, allow_non_precompiled = T.unsafe(nil)); end",
"def create\n @asset = Asset.new(asset_params)\n\t\n respond_to do |format|\n if @asset.save\n format.html { redirect_to @asset, notice: 'Asset was successfully created.' }\n format.json { render :show, status: :created, location: @asset }\n else\n format.html { render :new }\n format.json { render json: @asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def asset(name)\n path = Root.join name.to_s.sub(/^\\//, '')\n path.file? && path.readable? ? path : nil\n end",
"def create\n @primary_asset = PrimaryAsset.new(primary_asset_params)\n\n respond_to do |format|\n if @primary_asset.save\n format.html { redirect_to @primary_asset, notice: 'Primary asset was successfully created.' }\n format.json { render :show, status: :created, location: @primary_asset }\n else\n format.html { render :new }\n format.json { render json: @primary_asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def asset_params\n params[:asset].permit(:file_url, :title, :description)\n end",
"def create\n @asset = Asset.new(params[:asset])\n @asset.parse_meta\n if @asset.id? && Asset.exists?(@asset.id)\n @asset = Asset.find(@asset.id)\n @asset.user_id = nil\n @asset.submitted = true\n @asset.revision = false\n @asset.approved = false\n @asset.checked_out = false\n success = @asset.update_attributes(params[:asset])\n else\n success = @asset.save\n end\n\n respond_to do |format|\n if success\n format.html { redirect_to @asset, notice: 'Asset was successfully created.' }\n format.json { render json: @asset, status: :created, location: @asset }\n else\n format.html { render action: \"new\" }\n format.json { render json: @asset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def handle_asset_gatekeeper_ids\n handle_admin_role_ids Seek::Roles::ASSET_GATEKEEPER\n end",
"def handle_asset_gatekeeper_ids\n handle_admin_role_ids Seek::Roles::ASSET_GATEKEEPER\n end",
"def new\n repo = assets_repo\n @v_asset = repo.new\n\n respond_to do |format|\n format.html new.html.erb\n format.json { render json: @v_asset }\n end\n end",
"def assets_path\n @assets_path ||= 'assets'\n end",
"def public_compute_asset_path(source, options = T.unsafe(nil)); end"
] | [
"0.7437381",
"0.7437381",
"0.7250617",
"0.7250617",
"0.7250617",
"0.7032444",
"0.7032444",
"0.68833894",
"0.68833894",
"0.6676499",
"0.6676499",
"0.6676499",
"0.66683966",
"0.66683966",
"0.6537513",
"0.6537513",
"0.6313475",
"0.6312442",
"0.6229604",
"0.6145517",
"0.6087644",
"0.60687107",
"0.60285217",
"0.5989899",
"0.5985342",
"0.5961348",
"0.5961348",
"0.59313214",
"0.5916278",
"0.5891079",
"0.5865291",
"0.5863961",
"0.58628154",
"0.5857403",
"0.5852474",
"0.58394915",
"0.5836526",
"0.57872933",
"0.5785199",
"0.57835454",
"0.5783176",
"0.5772413",
"0.5772413",
"0.57475024",
"0.5728354",
"0.5709491",
"0.5704117",
"0.5695652",
"0.5676222",
"0.56595165",
"0.5654413",
"0.56360096",
"0.56220484",
"0.56202257",
"0.5615695",
"0.5612724",
"0.56055546",
"0.56041074",
"0.5580339",
"0.5580339",
"0.5580225",
"0.55769736",
"0.5570976",
"0.55707425",
"0.55699974",
"0.55699974",
"0.55699825",
"0.5569225",
"0.55565804",
"0.55512214",
"0.5539328",
"0.5533838",
"0.55257344",
"0.5515126",
"0.55032605",
"0.54977334",
"0.54935086",
"0.5490833",
"0.5483682",
"0.5456218",
"0.5453447",
"0.54517466",
"0.5437524",
"0.5430339",
"0.5429426",
"0.5428443",
"0.54177874",
"0.5415437",
"0.5411943",
"0.5409479",
"0.5409479",
"0.5402806",
"0.5396503",
"0.5394094",
"0.5386548",
"0.53819495",
"0.53816533",
"0.53816533",
"0.5380286",
"0.5378874",
"0.53785723"
] | 0.0 | -1 |
Creates a client connection to Riakpb's Protobuf Listener | def initialize(options={})
self.host = options[:host] || "127.0.0.1"
self.port = options[:port] || 8087
self.client_id = options[:client_id] unless options[:client_id].blank?
read_quorum = options[:r] || options[:read_quorum]
write_quorum = options[:w] || options[:write_quorum]
replica_commit = options[:dw] || options[:replica_commit]
return_body = options[:rb] || options[:return_body] || true
@options = options.slice!(:host, :port, :client_id, :r, :read_quorum, :w, :write_quorum, :dw, :replica_commit, :rb, :return_body)
@options[:r] = read_quorum unless read_quorum.blank?
@options[:w] = write_quorum unless write_quorum.blank?
@options[:dw] = replica_commit unless replica_commit.blank?
@options[:return_body] = return_body unless return_body.blank?
@buckets = []
@bucket_cache = Hash.new{|k,v| k[v] = Riakpb::Bucket.new(self, v, @options)}
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_message_listener\n begin\n message = @client.gets\n init_message(message)\n end until @client.closed?\n end",
"def initialize(listener)\n @listener = listener\n end",
"def open_listener\n @listener = PCAPRUB::Pcap.open_live(IFACE, 65535, false, 1)\n @listener.setfilter(\"tcp port #{@port} and tcp[tcpflags] & tcp-ack != 0\")\n end",
"def start\n\n self.listener = Rex::Socket::TcpServer.create(\n 'LocalHost' => self.listen_host,\n 'LocalPort' => self.listen_port,\n 'Context' => self.context,\n 'SSL' => self.ssl,\n 'SSLCert' => self.ssl_cert,\n 'SSLCompression' => self.ssl_compression,\n 'SSLCipher' => self.ssl_cipher,\n 'Comm' => self.comm\n )\n\n # Register callbacks\n self.listener.on_client_connect_proc = Proc.new { |cli|\n on_client_connect(cli)\n }\n self.listener.on_client_data_proc = Proc.new { |cli|\n on_client_data(cli)\n }\n\n self.listener.start\n end",
"def initialize\n @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createNetClient\n end",
"def connect\n start_listener!\n end",
"def init_client(args={}, &on_init)\n host,port = args[:host], args[:port]\n connection = @connections.find { |c| port == c.port && host == c.host }\n connection ||= EventMachine::connect(host, port, TCPConnection, args)\n on_init.call(connection) # TODO move to tcpnode event ?\n end",
"def initialize(client, storage)\n @client = client\n @storage = storage\n handshake\n init_message_listener\n end",
"def initialize(params={})\n # User configurable options\n params[:read_timeout] ||= 5\n params[:connect_timeout] ||= 3\n params[:connect_retry_interval] ||= 0.1\n params[:connect_retry_count] ||= 3\n\n # Server name and port where Doozer is running\n # Defaults to 127.0.0.1:8046\n params[:server] ||= '127.0.0.1:8046' unless params[:servers]\n\n # Disable buffering the send since it is a RPC call\n params[:buffered] = false\n\n logger.trace \"Socket Connection parameters\", params.dup\n\n # For each new connection\n params[:on_connect] = Proc.new do |socket|\n # Reset user_data on each connection\n socket.user_data = 0\n end\n\n @socket = ResilientSocket::TCPClient.new(params)\n end",
"def create_client(&callback)\n begin\n client_id = @server.generate_id\n end while @connected.containsKey(client_id)\n ping(client_id)\n @server.debug 'Created new client ?', client_id\n @server.trigger(:handshake, client_id)\n callback.call(client_id)\n end",
"def on_client_connect(cli)\n cli.extend(ServerClient)\n\n cli.init_cli(self)\n end",
"def init_client; end",
"def on_client_connect(client)\n end",
"def connect!\n host, port = @current_server.split(\":\")\n @socket = TCPSocket.new(host, port)\n @transport = Avro::IPC::SocketTransport.new(@socket)\n @requestor = Avro::IPC::Requestor.new(@options[:protocol], @transport)\n rescue Avro::AvroError, Errno::ECONNREFUSED, Errno::EPIPE, IOError => e\n @transport.close rescue nil\n raise e\n end",
"def init_socket\n @socket.close if @socket\n retry_count = 0\n begin\n @logger.info(\"[MSGPACK-RPC] Connecting to Msgpack-RPC server...\") if @logger\n @socket = TCPSocket.new(host, port)\n configure_socket_keepalive\n init_ssl if use_ssl\n rescue Errno::ECONNREFUSED\n @logger.error(\"[MSGPACK-RPC] Connection refused\") if @logger\n retry_count += 1\n if retry_count == max_connect_retries\n raise MsgpackRpcClient::Error, \"Could not connect to MsgPack-RPC server\"\n else\n sleep(connect_retry_wait)\n # might have a chance with a different instance\n retry\n end\n end\n # Attach streaming packer/unpacker to the socket\n @packer = MessagePack::Packer.new(@socket)\n @unpacker = MessagePack::Unpacker.new(@socket, symbolize_keys: true)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/datalabeling/v1beta1/data_labeling_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @data_labeling_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::DataLabeling::V1beta1::DataLabelingService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def init_socket\n @rcon_socket = RCONSocket.new @ip_address, @port\n @socket = SourceSocket.new @ip_address, @port\n end",
"def initialize(listener, params)\n @listener = listener\n @params = params\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/partner/aistreams/v1alpha1/aistreams_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.endpoint = @config.endpoint\n end\n\n @ai_streams_stub = ::Gapic::ServiceStub.new(\n ::Google::Partner::Aistreams::V1alpha1::AIStreams::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def open\n return if @connected\n\n socket = Thrift::Socket.new(@host, @port)\n\n @transport = Thrift::BufferedTransport.new(socket)\n @transport.open\n\n proto = Thrift::BinaryProtocol.new(@transport)\n @service = Protocol::ImpalaService::Client.new(proto)\n @connected = true\n end",
"def post_init\n puts \"Nugache #{@bot.port} Accepting client\" if @@debug\n if @bot.pm.peernodes.length > 9\n close_connection\n @data_suf = false\n else\n port, ip = Socket.unpack_sockaddr_in(get_peername)\n @peer = Peer.new(ip, port, self)\n @bot.pm.add(@peer)\n #@session = Session.new(@rsakey, @version)\n end\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/dialogflow/v2beta1/participant_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @participants_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Dialogflow::V2beta1::Participants::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def _client\n @client ||= XMLRPC::Client.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.port == 443, @timeout)\n end",
"def new_websocket_client(client)\n\n msg \"connecting to: %s:%s\" % [@target_host, @target_port]\n tsock = TCPSocket.open(@target_host, @target_port)\n\n if @verbose then puts @@Traffic_legend end\n\n begin\n do_proxy(client, tsock)\n rescue\n tsock.shutdown(Socket::SHUT_RDWR)\n tsock.close\n raise\n end\n end",
"def listen\n puts \"[#] rncp Listener: creating new connection\"\n l = bind_tcp\n puts \"[*] waiting for connections\" \n\n sock, info = l.accept\n printf \"[*] connection from %s:%s\\n\", info.ip_address, info.ip_port\n puts \"[*] receiving...\"\n\n data = \"\"\n while (sock.eof? == false)\n data += sock.gets()\n end\n\n untar data\n puts \"[*] received: \"\n\n puts \"[#] finished\"\n sock.close\n l.close\n end",
"def initialize(host, **options)\n self.logger = options[:logger]\n\n @reactor = ::Libuv.reactor\n\n @host = host\n @port = options[:port] || DEFAULT_PORT\n @bind_address = options[:bind_address] || '0.0.0.0'\n @options = options\n\n debug { \"establishing connection to #{@host}:#{@port}\" }\n\n actual_host = if IPAddress.valid?(@host)\n @host\n else\n @reactor.lookup(@host)[0][0]\n end\n\n @socket = PacketStream.new(self, **options)\n @socket.connect(actual_host, @port)\n\n debug { \"connection established\" }\n\n @host_key_verifier = select_host_key_verifier(options[:paranoid])\n @algorithms = Algorithms.new(self, options)\n @server_version = ServerVersion.new\n @socket.algorithms = @algorithms\n\n socket.direct_write \"#{::Net::SSH::Transport::ServerVersion::PROTO_VERSION}\\r\\n\"\n socket.start_read\n\n @algorithms.ready # Wait for this to complete\n end",
"def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end",
"def post_init\n log_debug '[client-cnxn] Post init, new read buffer created'\n @buffer = Protobuf::Rpc::Buffer.new :read\n rescue\n fail(:RPC_ERROR, 'Connection error: %s' % $!.message) unless failed?\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/dataproc/v1beta2/jobs_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.endpoint = @config.endpoint\n end\n\n @job_controller_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Dataproc::V1beta2::JobController::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize(opts)\n\n # Initializing with a single hash\n @options = opts.symbolize_keys\n\n @auto_pong = @options.fetch(:auto_pong, nil) || CapistranoSentinel.config.auto_pong\n @read_buffer_size = @options.fetch(:read_buffer_size, nil) || CapistranoSentinel.config.read_buffer_size\n @reconnect = @options.fetch(:reconnect, nil) || CapistranoSentinel.config.reconnect\n @retry_time = @options.fetch(:retry_time, nil) || CapistranoSentinel.config.retry_time\n\n\n @secure = @options.fetch(:secure, nil) || CapistranoSentinel.config.secure\n\n @host = @options.fetch(:host, nil) || CapistranoSentinel.config.host\n @port = @secure ? 443 : (@options.fetch(:port, nil) || CapistranoSentinel.config.port)\n @path = @options.fetch(:path, nil) || CapistranoSentinel.config.path\n @query = @options.fetch(:query, nil)\n\n @actor ||= @options.fetch(:actor, nil)\n @channel ||= @options.fetch(:channel, nil)\n\n\n @closed = false\n @opened = false\n\n @on_open = lambda {\n log_to_file(\"native websocket client websocket connection opened\")\n subscribe(@channel) if @channel.present?\n }\n\n @on_close = lambda { |message|\n log_to_file(\"#{@actor.class} client received on_close #{message.inspect}\")\n if @actor.present? && @actor.respond_to?(:on_close)\n if @actor.respond_to?(:async)\n @actor.async.on_close(message)\n else\n @actor.on_close(message)\n end\n end\n }\n\n @on_ping = lambda { |message|\n log_to_file(\"#{@actor.class} client received PING #{message.inspect}\")\n if @actor.present? && @actor.respond_to?(:on_ping)\n if @actor.respond_to?(:async)\n @actor.async.on_ping(message)\n else\n @actor.on_ping(message)\n end\n end\n }\n\n @on_error = lambda { |error|\n log_to_file(\"#{@actor.class} received ERROR #{error.inspect} #{error.backtrace}\")\n if @actor.present? && @actor.respond_to?(:on_error)\n if @actor.respond_to?(:async)\n @actor.async.on_error(error)\n else\n @actor.on_error(error)\n end\n end\n }\n\n @on_message = lambda { |message|\n message = parse_json(message)\n log_to_file(\"#{@actor.class} websocket client received JSON #{message}\")\n if @actor.present? && @actor.respond_to?(:async)\n log_to_file(\"#{@actor.class} works async on message #{message.inspect}\")\n @actor.async.on_message(message)\n else\n @actor.on_message(message)\n end\n }\n connect\n end",
"def post_init\n log_debug '[server] Post init, new read buffer created'\n @stats = Protobuf::Rpc::Stat.new(:SERVER, true)\n @stats.client = Socket.unpack_sockaddr_in(get_peername)\n \n @buffer = Protobuf::Rpc::Buffer.new(:read)\n @did_respond = false\n end",
"def worker_listener\n @worker_listener ||= ManageIQ::Messaging::Client.open(worker_listener_opts)\n end",
"def start\n subscribe &Proc.new { |message| listener(message) }\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/monitoring/v3/notification_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @notification_channel_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Monitoring::V3::NotificationChannelService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def client\n @client ||= \\\n V2::BigtableClient.new(\n credentials: channel(V2::BigtableClient::SERVICE_ADDRESS),\n timeout: timeout,\n client_config: client_config,\n lib_name: \"gccl\",\n lib_version: Google::Cloud::Bigtable::VERSION\n )\n end",
"def client(interface)\n fail_bad_interfaces(interface)\n @client ||= interface.new_connection(@data_layer_options)\n @client\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/channel/v1/service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @cloud_channel_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Channel::V1::CloudChannelService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/pubsublite/v1/admin_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.endpoint = @config.endpoint\n end\n\n @admin_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::PubSubLite::V1::AdminService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def post_init\n log_debug { '[server] Post init, new read buffer created' }\n @stats = Protobuf::Rpc::Stat.new(:SERVER, true)\n @stats.client = ::Socket.unpack_sockaddr_in(get_peername)\n @request_buffer = Protobuf::Rpc::Buffer.new(:read)\n @request = ::Protobuf::Socketrpc::Request.new\n @response = ::Protobuf::Socketrpc::Response.new\n\n @did_respond = false\n end",
"def initialize\n @connection = Bunny.new\n @connection.start\n @channel = @connection.create_channel\n end",
"def initialize(source, options)\n @source = source\n @host = options[:host]\n @port = options[:port]\n @schema_registry_url = options[:schema_registry_url]\n @schemas_path = options[:schemas_path]\n @transport = (options[:transport] || 'http').downcase\n @logger = options[:logger] || ::Logger.new(STDOUT)\n @cloudevents_specversion = options[:cloudevents_specversion] || '0.4-wip'\n @tag_prefix = options[:name]\n\n fluentd_logger_options = {\n host: @host,\n port: @port,\n logger: @logger\n }\n\n @fluentd_logger = if @transport.eql?('http')\n FluentHttpLogger.new(@tag_prefix, fluentd_logger_options)\n else\n Fluent::Logger::FluentLogger.new(@tag_prefix, fluentd_logger_options)\n end\n\n @avro = AvroTurf::Messaging.new(registry_url: @schema_registry_url, schemas_path: @schemas_path)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/devtools/build/v1/publish_build_event_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @publish_build_event_stub = ::Gapic::ServiceStub.new(\n ::Google::Devtools::Build::V1::PublishBuildEvent::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize(client)\n @buffer = String.new\n @client = client\n end",
"def create_client_socket\n\t\tself.log.debug \"Creating a CLIENT socket bound to: %s\" % [ self.server ]\n\t\tsock = CZTop::Socket::CLIENT.new\n\n\t\tclient_cert = Assemblage::Auth.local_cert\n\t\tserver_cert = Assemblage::Auth.remote_cert( 'server' )\n\n\t\tself.log.debug \"Connecting with %p and %p\" % [ client_cert, server_cert ]\n\t\tsock.CURVE_client!( client_cert, server_cert )\n\t\tsock.connect( self.server )\n\n\t\treturn sock\n\tend",
"def post_init\n self.dispatch_event(:on_connect, [self])\n self.send_data(SyncMessage.new($listen_port, $uuid).to_sendable)\n end",
"def get_client(client_class = ::Elarian::BaseClient)\n @default_client ||= client_class.new(connection_credentials)\n on_error = lambda do |error|\n puts \"Error occurred #{error}\"\n disconnect_and_stop_loop\n end\n @default_client.on(:error, on_error)\n connect(@default_client)\n @default_client\n end",
"def create_connection\n self.setup\n RfmAdaptor::Connection.new(self.server_name)\n end",
"def create\n conn = EM::Hiredis::Client.new(@host, @port, @password, @database)\n conn.connect\n conn\n end",
"def client\n @client ||= client_for_host(brine_root_url || 'http://localhost:8080',\n logging: ENV['BRINE_LOG_HTTP'])\n end",
"def request_listen\n send_command RemoteListenCommand.new(@client.remote_listen_address)\n enable_tunnel_timeouts \n end",
"def lightblue_client\n config = LightblueConf::VALUES.merge(\n :cert_file => fake_cert_file.path,\n :logger => Rails.logger\n )\n Lightblue::Client.new(config)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/ads/google_ads/v3/services/mutate_job_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n credentials ||= Credentials.default scope: @config.scope\n if credentials.is_a?(String) || credentials.is_a?(Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.endpoint = @config.endpoint\n end\n\n @mutate_job_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Ads::GoogleAds::V3::Services::MutateJobService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def run!\n client.on(:hello, &responder.hello)\n client.on(:message, &responder.message)\n client.start!\n end",
"def connect!\n @connection = Connection::Factory.create(@options[:transport], @options[:transport_wrapper], @current_server, @options[:timeout])\n @connection.connect!\n @client = @client_class.new(@options[:protocol].new(@connection.transport, *@options[:protocol_extra_params]))\n rescue Thrift::TransportException, Errno::ECONNREFUSED => e\n @transport.close rescue nil\n raise e\n end",
"def configure_client(options={})\n socket.client.set(options)\n end",
"def initialize_client\n secret = Settings['xml_rpc'] ? Settings.xml_rpc['secret'] : nil\n endpoint = Settings['xml_rpc'] ? Settings.xml_rpc['endpoint'] : nil\n fail ArgumentError, \"#{endpoint} is not a valid URL.\" if endpoint && !uri?(endpoint)\n\n @client = OpenNebula::Client.new(secret, endpoint)\n end",
"def initialize(client)\n self.client = client\n\n # register the inbound handler for the tcp server channel (allowing us to\n # receive new client connections to a tcp server channel)\n client.register_inbound_handler(Rex::Post::Meterpreter::Extensions::Stdapi::Net::SocketSubsystem::TcpServerChannel)\n\n end",
"def init\n \n # Setup Slack\n Slack.configure do |config|\n config.token = ENV['SLACK_TOKEN']\n if not config.token\n puts('Missing ENV[SLACK_TOKEN]! Exiting program')\n exit\n end\n end\n @client = Slack::RealTime::Client.new\n @client.on :hello do\n puts(\"Connected '#{@client.self['name']}' to '#{@client.team['name']}' team at https://#{@client.team['domain']}.slack.com.\")\n end\n\n # Setup GA\n @GA_manager = Galerts::Manager.new(ENV['GMAIL_USER'], ENV['GMAIL_PASS'])\n @alert_cache = @GA_manager.alerts\n \n # Setup message hooks\n setupMessageHook()\n\n # Cleanup hooks\n @client.on :close do |_data|\n puts 'Connection closing, exiting.'\n EM.stop\n end\n @client.on :closed do |_data|\n puts 'Connection has been disconnected.'\n end\n\n # Run this bad boy\n @client.start!\n \nend",
"def create_client_connection(host, port, db)\n Connection.new(host, port, db, @handle)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/pubsub/v1/pubsub_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @iam_policy_client = Google::Iam::V1::IAMPolicy::Client.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @publisher_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::PubSub::V1::Publisher::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def main\n s = GRPC::RpcServer.new\n s.add_http2_port('0.0.0.0:50051', :this_port_is_insecure)\n s.handle(RequesterServer)\n s.run_till_terminated\nend",
"def main\n s = GRPC::RpcServer.new\n s.add_http2_port('0.0.0.0:50051', :this_port_is_insecure)\n s.handle(CalculadoraServer)\n s.run_till_terminated\nend",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/netapp/v1/cloud_netapp_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @location_client = Google::Cloud::Location::Locations::Client.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @net_app_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::NetApp::V1::NetApp::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def init_client(uri, &on_init)\n connection = nil\n @connections_lock.synchronize {\n connection = @connections.find { |c|\n c.url == uri\n }\n if connection.nil?\n connection = EventMachine::WebSocketClient.connect(uri)\n connection.callback do\n on_init.call(connection)\n end\n @connections << connection\n # TODO sleep until connected?\n else\n on_init.call(connection)\n end\n }\n connection\n end",
"def client\n puts \"creating client\"\n @client ||= Vineyard::Client.new(options) #unless defined?(@client) && @client.hash == options.hash\n @client\n end",
"def create_client(mechanism_name)\n peer = Peer.new(@context, mechanism_name, :client)\n @peers[peer.session.address] = peer\n peer\n end",
"def run\n @security = Communication::Security.new_client\n\n @subscribe_socket = Communication::SubscribeSocket.new_link(\n Pantry.config.server_host,\n Pantry.config.pub_sub_port,\n @security\n )\n @subscribe_socket.add_listener(self)\n @subscribe_socket.filter_on(@listener.filter)\n @subscribe_socket.open\n\n @send_socket = Communication::SendSocket.new_link(\n Pantry.config.server_host,\n Pantry.config.receive_port,\n @security\n )\n @send_socket.open\n\n @file_service = Communication::FileService.new_link(\n Pantry.config.server_host,\n Pantry.config.file_service_port,\n @security\n )\n @file_service.start_client\n end",
"def initialize(**options)\n @config = Configuration.new(**options)\n @client = Client.new(config)\n end",
"def initialize( connection, log, buffers, type )\n @connection = connection\n @log = log\n @buffers = buffers\n @type = type\n @local_id = @connection.allocate_channel_id\n @local_window_size = 0x20000\n @local_maximum_packet_size = 0x10000\n end",
"def client\n @client_ ||= Libmagellan.new(MAGELLAN_HTTP_SERVER,\n consumer_key: MAGELLAN_CONSUMER_KEY,\n consumer_secret: MAGELLAN_CONSUMER_SECRET,\n client_version: MAGELLAN_CLIENT_VERSION,\n mqtt_host: MAGELLAN_MQTT_SERVER_HOST,\n mqtt_port: MAGELLAN_MQTT_SERVER_PORT)\n end",
"def start_websocket_client\n # make sure log level is still set correctly here\n Bixby::Log.setup_logger(:level => Logging.appenders[\"file\"].level)\n logger.info \"Started Bixby Agent #{Bixby::Agent::VERSION}\"\n @client = Bixby::WebSocket::Client.new(Bixby.agent.manager_ws_uri, AgentHandler)\n trap_signals()\n @client.start\n end",
"def start\r\n @thread = Thread.new {\r\n @server.connect\r\n @proto.fire_pseudo(:connect, {address: @server.address?, port: @server.port?})\r\n protos = @server.read\r\n while protos != nil && @halt != true\r\n protos.each do |proto|\r\n Log::write \"<= \" + proto\r\n @proto.parse_proto(proto)\r\n end\r\n protos = @server.read\r\n end\r\n }\r\n end",
"def initialize\n\n logger.info(\"Starting WebSocketServer...\")\n \n end",
"def listener(options={},&blk)\n raise \"Cannot call listener inside another listener block.\" if (@listener or @listener_name)\n ops = resolve_defaults(options)\n ops[:num_processors] ||= 950\n ops[:timeout] ||= 0\n\n @listener = Mongrel::HttpServer.new(ops[:host], ops[:port].to_i, ops[:num_processors].to_i, ops[:timeout].to_i)\n @listener_name = \"#{ops[:host]}:#{ops[:port]}\"\n @listeners[@listener_name] = @listener\n\n if ops[:user] and ops[:group]\n change_privilege(ops[:user], ops[:group])\n end\n\n # Does the actual cloaking operation to give the new implicit self.\n if blk\n cloaker(&blk).bind(self).call\n end\n\n # all done processing this listener setup, reset implicit variables\n @listener = nil\n @listener_name = nil\n end",
"def initialize(username, password, hostname, port)\n @username = username\n @password = password\n @hostname = hostname\n @port = port\n @listeners = []\n @connected = false\n @session_id = nil\n @connection_hash = nil\n @packets_received = 0 # keep track of number of packets received\n @last_packets = [nil]*4 # keep track of last 4 packets\n\n listen { |packet| handle_packet(packet) }\n end",
"def initialize(host, port, service)\n @rpc = RpcClient.new(host, port)\n @service = service\n end",
"def initialize(options={})\n @host = options.fetch(:host)\n @port = options.fetch(:port)\n @use_ssl = options.fetch(:use_ssl, false)\n @logger = options.fetch(:logger, nil)\n @max_retries = options.fetch(:max_retries, DEFAULT_MAX_RETRIES)\n @max_connect_retries = options.fetch(:max_connect_retries, DEFAULT_MAX_CONNECT_RETRIES)\n @connect_retry_wait = options.fetch(:connect_retry_wait, DEFAULT_CONNECT_RETRY_WAIT)\n @msgid = 1\n @call_mutex = Mutex.new\n init_socket\n end",
"def initialize(type: :tcp, host: 'localhost', port: 27077, api_key: nil, default_options: {})\n @enabled = true\n @collect_file_and_line = false\n\n self.host = host\n self.port = port\n self.level = Logvoyage::DEBUG\n self.rescue_network_errors = false\n api_key ||= Logvoyage.api_key\n\n self.default_options = default_options\n self.default_options['version'] = VERSION\n self.default_options['host'] ||= Socket.gethostname\n self.default_options['level'] ||= Logvoyage::UNKNOWN\n self.default_options['facility'] ||= 'logvoyage-rb'\n\n @sender = case type\n when :udp then UdpSender.new host: host, port: port, api_key: api_key\n when :tcp then TcpSender.new host: host, port: port, api_key: api_key\n when :http then HttpSender.new host: host, port: port, api_key: api_key\n else raise \"Unknown #{sender}\"\n end\n self.level_mapping = :logger\n end",
"def client\n @client ||= ActiveSupport::MessageEncryptor.new(@key, cipher: 'aes-256-cbc')\n end",
"def client\n set_connection unless @client\n @client\n end",
"def initialize(uri, config, client)\n\t\t\t@uri = uri\n\t\t\t@client = client\n\t\t\t@srv_requestq = Queue.new\n\n\t\t\tmsg = DRbMessage.new(config)\n\n\t\t\t# Read-thread\n\t\t\tThread.new do\n\t\t\t\t# Read from client, and delegate request/reply to the correct place.\n\t\t\t\tbegin\n\t\t\t\t\tloop do\n\t\t\t\t\t\ttype = msg.load(client.read_fd)\n\t\t\t\t\t\tif type == 'req'\n\t\t\t\t\t\t\t@srv_requestq.push(msg.recv_request(client.read_fd))\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tclient.receiveq.push(msg.recv_reply(client.read_fd))\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\trescue\n\t\t\t\t\tclient.receiveq.push($!)\n\t\t\t\t\t@srv_requestq.push($!)\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t# Write-thread\n\t\t\tThread.new do\n\t\t\t\t# Wait for outgoing data on send queue, and add header-packet before\n\t\t\t\t# writing.\n\t\t\t\tbegin\n\t\t\t\t\tloop do\n\t\t\t\t\t\ttype, data = client.sendq.pop\n\n\t\t\t\t\t\tclient.write_fd.write(msg.dump(type))\n\n\t\t\t\t\t\tif type == 'req'\n\t\t\t\t\t\t\tmsg.send_request(client.write_fd, *data)\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tmsg.send_reply(client.write_fd, *data)\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\trescue\n\t\t\t\t\tclient.receiveq.push($!)\n\t\t\t\t\t@srv_requestq.push($!)\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def initialize(host: 'localhost', port: 2113, username: nil, password: nil)\n @username = username\n @password = password\n @conn = connection(host, port)\n @serializer = EventSerializer.new\n end",
"def reinit_client\n ::Fluent::Logger::FluentLogger.open(nil, :host => fluent_host, :port => fluent_port)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/aiplatform/v1/vizier_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @location_client = Google::Cloud::Location::Locations::Client.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @iam_policy_client = Google::Iam::V1::IAMPolicy::Client.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @vizier_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::AIPlatform::V1::VizierService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize(client)\n\t\tself.client = client\n\n\t\t# register the inbound handler for the tcp server channel (allowing us to receive new client connections to a tcp server channel)\n\n\tend",
"def start\n @client.on :hello do\n puts \"Successfully connected, welcome '#{@client.self.name}' to the '#{@client.team.name}' team at https://#{@client.team.domain}.slack.com.\"\n end\n @client.on :close do |_data|\n puts \"Client is about to disconnect\"\n end\n @client.on :closed do |_data|\n puts \"Client has disconnected successfully!\"\n end\n\n @client.on :message do |data|\n message = data.text\n bot_id = @client.self.id\n if self.needs_help?(message, bot_id)\n @client.message channel: data.channel, text: self.respond_help\n else\n symbol_doc = self.read(message, bot_id)\n if self.must_respond?(symbol_doc)\n if symbol_doc.success\n @client.message channel: data.channel, text: self.respond_ok(symbol_doc)\n else\n if message.split.count > 1\n @client.message channel: data.channel, text: self.respond_error(symbol_doc)\n end\n end\n end\n end\n end\n\n @client.start!\n end",
"def initialize\n @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createNetServer\n end",
"def initialize(options)\n host = { :host => options[:host], :port => options[:port] }\n host[:passcode] = options[:password] if options[:password]\n host[:login] = options[:username] if options[:username]\n\n headers = {}\n unless options[:heartbeat] == false\n headers.merge!(\n :host => options[:host],\n :\"accept-version\" => \"1.2\",\n :\"heart-beat\" => \"2000,0\")\n end\n headers[:\"client-id\"] = options[:client_ref] if options[:client_ref]\n\n @stomp_client = ::Stomp::Client.new(:hosts => [host], :connect_headers => headers)\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/translate/v3/translation_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @translation_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Translate::V3::TranslationService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/maps/fleetengine/v1/trip_api_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @trip_service_stub = ::Gapic::ServiceStub.new(\n ::Maps::Fleetengine::V1::TripService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/monitoring/v3/uptime_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @uptime_check_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Monitoring::V3::UptimeCheckService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def new_connection; end",
"def establish_connection_with_server\n\t $game_client = GameClient.new\n $scene = Scene_Pong_Client.new\n end",
"def create_socket\n if @uri.scheme == 'wss'\n create_ssl_socket.tap(&:connect)\n else\n TCPSocket.new(@uri.host, @port)\n end\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"garbage/garbage_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @operations_client = Operations.new do |config|\n config.credentials = credentials\n config.quota_project = @quota_project_id\n config.endpoint = @config.endpoint\n end\n\n @garbage_service_stub = ::Gapic::ServiceStub.new(\n ::So::Much::Trash::GarbageService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/spanner/v1/spanner_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @spanner_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Spanner::V1::Spanner::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/bigtable/v2/bigtable_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @bigtable_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::Bigtable::V2::Bigtable::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def run\n require 'client'\n\n begin\n client = Client.new params[:address].value, params[:port].value\n puts \"Connected to Chain Reactor server, version #{client.version}\"\n data_input = params[:data].value\n\n if data_input\n client.send(data_input.gets.strip)\n else\n client.send_as_json(get_hash_from_stdin)\n client.close()\n end\n exit_status exit_success\n rescue ClientError => e\n STDERR.puts e.message\n exit_status exit_failure\n rescue SystemExit, Interrupt\n STDERR.puts \"Caught exit signal\" \n exit_status exit_failure\n rescue Exception => e\n STDERR.puts \"An error occured {#{e.class.name}}: #{e.message}\" \n exit_status exit_failure\n end\n end",
"def initialize\n # These require statements are intentionally placed here to initialize\n # the gRPC module only when it's required.\n # See https://github.com/googleapis/toolkit/issues/446\n require \"gapic/grpc\"\n require \"google/cloud/discoveryengine/v1beta/conversational_search_service_services_pb\"\n\n # Create the configuration object\n @config = Configuration.new Client.configure\n\n # Yield the configuration if needed\n yield @config if block_given?\n\n # Create credentials\n credentials = @config.credentials\n # Use self-signed JWT if the endpoint is unchanged from default,\n # but only if the default endpoint does not have a region prefix.\n enable_self_signed_jwt = @config.endpoint == Configuration::DEFAULT_ENDPOINT &&\n [email protected](\".\").first.include?(\"-\")\n credentials ||= Credentials.default scope: @config.scope,\n enable_self_signed_jwt: enable_self_signed_jwt\n if credentials.is_a?(::String) || credentials.is_a?(::Hash)\n credentials = Credentials.new credentials, scope: @config.scope\n end\n @quota_project_id = @config.quota_project\n @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id\n\n @conversational_search_service_stub = ::Gapic::ServiceStub.new(\n ::Google::Cloud::DiscoveryEngine::V1beta::ConversationalSearchService::Stub,\n credentials: credentials,\n endpoint: @config.endpoint,\n channel_args: @config.channel_args,\n interceptors: @config.interceptors\n )\n end",
"def client\n unless $client\n u = amqp_url\n conn = Bunny.new(u)\n conn.start\n $client = conn.create_channel\n\n # We only want to accept one un-acked message\n $client.prefetch(1)\n end\n $client\nend"
] | [
"0.61132884",
"0.5746174",
"0.5737131",
"0.5733513",
"0.57036215",
"0.5699631",
"0.5673083",
"0.5664639",
"0.5643266",
"0.55858773",
"0.5562572",
"0.5560142",
"0.55301726",
"0.5480431",
"0.5445003",
"0.54343826",
"0.5417622",
"0.54106706",
"0.53998333",
"0.539048",
"0.5383147",
"0.53602344",
"0.5358264",
"0.5334399",
"0.53047025",
"0.5294253",
"0.5283766",
"0.5269395",
"0.52643466",
"0.5261012",
"0.52286685",
"0.52217007",
"0.5219317",
"0.5215825",
"0.52144325",
"0.52063894",
"0.52012354",
"0.51998585",
"0.51977473",
"0.5181238",
"0.5178695",
"0.51778597",
"0.517519",
"0.51707697",
"0.5167548",
"0.5149073",
"0.51467115",
"0.51451707",
"0.5137803",
"0.51347184",
"0.5128234",
"0.5127705",
"0.51231074",
"0.5113412",
"0.511226",
"0.51107836",
"0.5110571",
"0.51072",
"0.5103098",
"0.51022524",
"0.5094972",
"0.50895315",
"0.50867933",
"0.50862604",
"0.5080119",
"0.5072879",
"0.50717837",
"0.50669724",
"0.5062776",
"0.5051681",
"0.50515115",
"0.5050324",
"0.5040836",
"0.50387514",
"0.5032275",
"0.5031797",
"0.5031727",
"0.50294507",
"0.50273085",
"0.5026977",
"0.50239325",
"0.5019175",
"0.5016773",
"0.5015294",
"0.5014123",
"0.50131905",
"0.5003016",
"0.5002797",
"0.5002577",
"0.5000199",
"0.49987173",
"0.49979946",
"0.49945712",
"0.49867454",
"0.4985101",
"0.4976462",
"0.49755222",
"0.496788",
"0.49671492",
"0.49670947"
] | 0.51606417 | 45 |
Establish a connection to the riak node, and store the Rpc instance | def rpc(options={})
options[:client_id] ||= @client_id if @client_id
@rpc ||= Rpc.new(self)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spawn_connection\n connect\n end",
"def establish\n @proxy = XMLRPC::Client.new(@hostname, '/RPC2', @port).proxy(@proxy_name)\n end",
"def connect\n return true if @status == :connected\n connection_options = {\n host: @host,\n port: @port,\n user: @user,\n password: @password,\n path: @path,\n use_ssl: @use_ssl,\n }\n @server = ::XMLRPC::Client.new3(connection_options)\n @status = :connected\n end",
"def riak\n @riak ||= Riak::Client.new(host: TestChamber.target_url.split('/').last, pb_port: 8087, protocol: 'pbc')\n end",
"def connect\n @connection.create\n end",
"def connect\n Connection.new\n end",
"def connect\n @cluster.connect\n end",
"def connect\n connection.tap do |c|\n c.start\n end\n end",
"def connect\n connection.connect\n nil\n end",
"def connect\n # backwards compatible code\n @host ||= ::Ragnar::Config.host\n @port ||= ::Ragnar::Config.port\n @connection = ::AMQP.connect({:host => @host, :port => @port})\n end",
"def establish_connection\n end",
"def connect\n @comm.connect(opts.user, opts.password, opts.server)\n end",
"def connect\n @connector.connect\n @p.set_connection @connector\n end",
"def connect\n @client = Redis.new(host: @host, port: @port)\n @logger.info(\"Connecting to database #{@host}:#{@port}\")\n end",
"def connect\n end",
"def initialize(args = {})\n @rjr_node = args[:rjr_node]\n @host = args[:host]\n @port = args[:port]\n\n @send_lock = Mutex.new\n @data = \"\"\n @rjr_node.add_connection(self)\n end",
"def connect!; end",
"def connect!; end",
"def create_connection\n self.setup\n RfmAdaptor::Connection.new(self.server_name)\n end",
"def establish_connection\n LOG.debug self.inspect\n LOG.debug \"establish_connection:\"\n LOG.debug([@config['CONNECTION_HOST'], @config['CONNECTION_PORT']].inspect)\n @socket = TCPSocket.new(@config['CONNECTION_HOST'], @config['CONNECTION_PORT']) # The port should be an arg.\n handshake_data_hash = {:ident => @config['IDENT'], :pid => Process.pid}\n @socket.write_object(handshake_data_hash)\n end",
"def connect\r\n if @opts[:threadsafe]\r\n @conns = Knj::Threadhandler.new\r\n \r\n @conns.on_spawn_new do\r\n self.spawn\r\n end\r\n \r\n @conns.on_inactive do |data|\r\n data[:obj].close\r\n end\r\n \r\n @conns.on_activate do |data|\r\n data[:obj].reconnect\r\n end\r\n else\r\n @conn = self.spawn\r\n end\r\n end",
"def connect!\n @connection = Connection::Factory.create(@options[:transport], @options[:transport_wrapper], @current_server, @options[:timeout])\n @connection.connect!\n @client = @client_class.new(@options[:protocol].new(@connection.transport, *@options[:protocol_extra_params]))\n rescue Thrift::TransportException, Errno::ECONNREFUSED => e\n @transport.close rescue nil\n raise e\n end",
"def connection(host)\n RobotArmy::GateKeeper.shared_instance.connect(host)\n end",
"def connect\n @connection.open\n end",
"def connect\n @connection_manager.connect\n end",
"def run\n connect\n end",
"def connect!\n host, port = @current_server.split(\":\")\n @socket = TCPSocket.new(host, port)\n @transport = Avro::IPC::SocketTransport.new(@socket)\n @requestor = Avro::IPC::Requestor.new(@options[:protocol], @transport)\n rescue Avro::AvroError, Errno::ECONNREFUSED, Errno::EPIPE, IOError => e\n @transport.close rescue nil\n raise e\n end",
"def connection\n @connection ||= Oedipus::Connection.new(host: \"127.0.0.1\", port: 9399, verify: false)\n end",
"def connect!\n end",
"def new_connection; end",
"def connect; end",
"def start\n self.connect\n self.login if @connected\n end",
"def connect(*) end",
"def connect\n client.connect(config.host, config.port)\n client.auth(config.password)\n client.send(Jabber::Presence.new.set_type(:available))\n\n self.roster = Jabber::Roster::Helper.new(client)\n roster.wait_for_roster\n\n self.rooms = self.config.rooms.collect do |room_name|\n Robut::Room.new(self, room_name).tap {|r| r.join }\n end\n\n if self.config.enable_private_messaging\n Robut::PM.new(self, rooms)\n end\n\n trap_signals\n self\n end",
"def connect\n @connection_pool.get_connection\n end",
"def connection\n @connection.connect\n end",
"def node\n return @node if @node\n Rbeapi::Client.load_config(ENV['RBEAPI_CONF']) if ENV['RBEAPI_CONF']\n connection_name = ENV['RBEAPI_CONNECTION'] || 'localhost'\n @node = Rbeapi::Client.connect_to(connection_name)\n end",
"def connect\n\tend",
"def connect(host=\"localhost\", port=2230)\n output_stream.puts \"sending request for a new game...\"\n EventMachine::run {\n EventMachine::connect host, port, GameBroker, &method(:setup_handler)\n }\n end",
"def connect(*args, &block)\n self.connection = RStomp::Connection.open(configuration.to_hash)\n # If the connection has swapped hosts, then swap out primary and secondary\n if connection.current_host != configuration.host\n configuration.secondary_host = configuration.host\n configuration.host = connection.current_host\n end\n\n # If the connection has swapped ports, then swap out primary and secondary\n if connection.current_port != configuration.port\n configuration.secondary_port = configuration.port\n configuration.port = connection.current_port\n end\n end",
"def tend_connection\n if @tend_connection.nil? || @tend_connection.closed?\n @tend_connection = Cluster::CreateConnection.(cluster, host)\n end\n @tend_connection\n end",
"def start\n _connect\n sleep 1\n end",
"def connect\n @redis ||= create\n end",
"def _client\n @client ||= XMLRPC::Client.new(@uri.host, @uri.path, @uri.port, nil, nil, nil, nil, @uri.port == 443, @timeout)\n end",
"def connect!\n start_em\n @client.ensure_connect\n end",
"def establish_connection(options={})\n\t\tconnection.ensure_tunnel(options)\n\tend",
"def connect(options = {})\n @connection ||= ::RbRouting::Connection.new(options)\n end",
"def connect\n connection = Bunny.new(connection_attributes.\n merge(:pass => connection_attributes[:password]))\n connection.start\n \n # NOTE: This is a super undocumented feature that you will probably know\n # about only from reading AMQP specs. If we want to subscribe, but abort\n # subscription before all messages are read, we need to turn this on,\n # otherwise the server will go on and deliver all remaining messages in\n # turn. See also the :ack => true flag in ServerTransport... 23Dez09, ksc\n connection.qos\n\n connection\n end",
"def create\n conn = EM::Hiredis::Client.new(@host, @port, @password, @database)\n conn.connect\n conn\n end",
"def connection\n @connection = create_connection! unless connected?\n @connection\n end",
"def initialize(config, remote_host, remote_port)\n @config = config\n @remote_nodes = []\n @local_node = Node.new(@config[\"local_host\"], @config[\"local_port\"])\n @need_token = false\n @has_token = false\n @ricart_agrawala = RicartAgrawala.new(self)\n join_network(remote_host, remote_port)\n start_server\n end",
"def initialize(options={})\n @connection = OctocatHerder::Connection.new(options)\n end",
"def connection\n @connection ||= KJess::Connection.new( host, port )\n end",
"def establish_connection(config=nil)\n super\n ensure_logger\n connection.connect\n # Make irb users happy with a 'true'\n true\n end",
"def establish_connection\n if @socket.nil?\n @socket = TCPSocket.new(@host, @port)\n end\n end",
"def establish_connection\n if @socket.nil?\n @socket = TCPSocket.new(@host, @port)\n end\n end",
"def connect(options = {})\n conn = self.connection(options[:handler])\n conn.container = self.container_id || generate_uuid\n connector = Connector.new(conn)\n conn.overrides = connector\n if !options[:url].nil?\n connector.address = URLs.new([options[:url]])\n elsif !options[:urls].nil?\n connector.address = URLs.new(options[:urls])\n elsif !options[:address].nil?\n connector.address = URLs.new([Qpid::Proton::URL.new(options[:address])])\n else\n raise ::ArgumentError.new(\"either :url or :urls or :address required\")\n end\n\n connector.heartbeat = options[:heartbeat] if !options[:heartbeat].nil?\n if !options[:reconnect].nil?\n connector.reconnect = options[:reconnect]\n else\n connector.reconnect = Backoff.new()\n end\n\n connector.ssl_domain = SessionPerConnection.new # TODO seems this should be configurable\n\n conn.open\n\n return conn\n end",
"def connection\n @connection ||= Bunny.new RabidMQ::Config.load_config\n end",
"def open_connection\n # FIXME il timeout serve solamente nella versione tcp\n # FIXME perchè utilizzare un'istanza di classe? non sarebbe meglio avere un metodo che genera il transport\n # e successivamente viene utilizzato sempre quello?\n Timeout.timeout @timeout do\n case @transport\n when :tcp\n @connection = KonoEppClient::Transport::TcpTransport.new(server, port)\n when :http\n @connection = KonoEppClient::Transport::HttpTransport.new(server, port,\n ssl_version: ssl_version,\n cookie_file: \"#{@tag.downcase}.cookies.pstore\"\n )\n end\n end\n end",
"def connect\n start_listener!\n end",
"def connect\n nodes.each do |k,v|\n rs_storage = RSpec.configuration.rs_storage[:nodes][k]\n raise RuntimeError, \"No internal storage for node #{k}\" if rs_storage.nil?\n\n ipaddress = rs_storage[:ipaddress]\n raise RuntimeError, \"No ipaddress provided from launch phase for node #{k}\" if ipaddress.nil?\n\n chan = ssh_connect(:host => k, :user => 'root', :net_ssh_options => {\n :keys => vmconf[:ssh_keys].split(\":\"),\n :host_name => ipaddress,\n })\n RSpec.configuration.rs_storage[:nodes][k][:ssh] = chan\n end\n\n nil\n end",
"def link(rest = nil)\n host = rest[0]\n port = rest[1]\n \n begin\n @daemon = XMLRPC::Client.new(host, nil, port, nil, nil, nil, nil, true, nil)\n rescue Exception => e\n puts \"There was an error trying to connect to the daemon.\"\n puts e.inspect\n end\n end",
"def connect \n log \"Connecting\"\n @socket = TCPSocket.new(config[:server], 6667)\n write \"USER #{config[:nick]} #{config[:nick]} #{config[:nick]} :#{config[:nick]}\"\n write \"NICK #{config[:nick]}\"\n write \"JOIN ##{config[:channel]}\"\n end",
"def connection\n client.send(:connection)\n end",
"def connect\n # Implement in subclass\n end",
"def connect\n @interface.connect\n end",
"def main\r\n # Generate RSA Keys\r\n primes = generate_primes(12)\r\n keys = generate_rsa_keys(primes[0], primes[1])\r\n key_public = [keys[0], keys[2]]\r\n key_private = [keys[1], keys[2]]\r\n\r\n # Establish Node Server\r\n node_details = set_node_details\r\n port = node_details[0]\r\n name = node_details[1]\r\n node_type = node_details[2]\r\n if (node_details.length == 3) # Node Details Returns Required Values\r\n initialize_server(port)\r\n set_routes(port, name, node_type, keys)\r\n else # Node Details Returns An Error\r\n puts \"Error: #{node_details}\"\r\n $status = \"Error: #{node_details}\"\r\n end\r\n\r\n # Discover Peers Parallely To Other Crypto Fucntions (Hence New Thread)\r\n Thread.new {\r\n discover_peers(port, key_private)\r\n new_block(GENESIS_REWARD, 1801, port, key_private) if (port == 1801)\r\n begin\r\n Faraday.post(\"#{URL}:1801/genesis\") if (port != 1801) # Get First Block in Blockchain From Genesis Node\r\n rescue\r\n # Node Responts With No Data\r\n end\r\n }\r\n\r\n Thread.new { Interface.new(port, key_public, key_private).show }\r\nend",
"def open\n return if @connected\n\n socket = Thrift::Socket.new(@host, @port)\n\n @transport = Thrift::BufferedTransport.new(socket)\n @transport.open\n\n proto = Thrift::BinaryProtocol.new(@transport)\n @service = Protocol::ImpalaService::Client.new(proto)\n @connected = true\n end",
"def connect\n @logger.request \"Connecting to Asterisk Manager (\" + @host + \":\" + @port + \")\"\n\n begin\n # Try to open a socket\n @socket = TCPSocket.new @host, @port\n\n # Parse the initial connection message. This message is sent right after a socket connection is established, and consists \n # of one line of the format: Asterisk Call Manager/1.1 \n @connected = (@socket.gets.gsub(\"\\r\\n\", \"\") == RESPONSE_CONNECTION)\n @logger.response(\"Success: Connection Established\") if @connected\n @logger.fatal(\"Error: Connection response did not match expected: \" + RESPONSE_CONNECTION) if !@connected\n rescue Exception => e\n @logger.fatal \"Error: Connection error occurred: \" + e.message\n @connected = false\n end\n end",
"def test!\n @connection = Connection.new 14000\n @bitcoin = BlockrIo.new true\n end",
"def fork\n Prefab::Client.new(@options)\n end",
"def connect\n begin\n @mSocket = Net::Telnet::new(\"Host\" => @mHostname,\"Port\" => @mPort)\n print(\"addr| \", @mSocket.addr.join(\":\"), \"\\n\")\n print(\"peer| \", @mSocket.peeraddr.join(\":\"), \"\\n\")\n @mSocket.puts \"USER rubybot 0 * Testing\"\n @mSocket.puts \"NICK #{@mNick}\"\n @mSocket.puts \"JOIN #{@mChannel}\"\n @mSocket.puts \"PRIVMSG NickServ identify ruby-bot\"\n\n # Status of -1 is active / connected\n # I know, this doesn't make much sense\n @mStatus = -1\n\n # print the silly message for the lolz\n rubicante_message \n rescue SocketError\n storeDebug(\"can't connect\")\n end\n end",
"def initialize secret = Time.now.to_f, uri = OPENDHT_URI\n @uri = uri\n uri = URI.parse(@uri)\n\n @rpc = XMLRPC::Client.new3(\n :host => uri.host,\n :port => uri.port,\n :path => uri.path\n )\n @secret = secret.to_s\n @internal_hash = Hash.new { |h,k|\n h[k] = RemoteArray.new(k, @secret, @uri)\n }\n self.debug_output = nil\n self.debug_output = Logger.new($stdout) if $DEBUG\n end",
"def connect\n debug \"setting up.. jid #{base.config[:account_jid]}\" \n cl = Jabber::Client.new(Jabber::JID::new(base.config[:account_jid]))\n @client = cl\n begin\n debug \"connect\"\n cl.connect \n debug \"auth\"\n cl.auth base.config[:account_password]\n # XXX should catch only proper exception types (including Jabber::ClientAuthenticationFailure)\n rescue Exception => ex \n debug \"EX: #{ex.class} \"\n debug ex.backtrace\n @base.auth_failure \n end\n \n @roster = Jabber::Roster::Helper.new cl \n @roster.add_presence_callback do |item,oldpres,pres|\n pres = Jabber::Presence.new unless pres\n oldpres = Jabber::Presence.new unless oldpres \n status = pres.status.to_s\n presence = pres.show || :available\n jid = item.jid\n # XXX unavaliable\n presence = :unavailable if pres.status.to_s == 'unavailable'\n debug \"item #{jid} chaged presence to #{presence} status #{status}\"\n base.item_presence_change(jid.to_s,presence,status)\n end\n \n @base.roster_items = get_roster_items\n\n @client.send Jabber::Presence.new\n \n set_presence\n\n cl.add_message_callback do |m|\n if m.type != :error\n debug \"message received from #{m.from} type #{m.type}\"\n @base.message_received(m.from.to_s,m.body)\n end\n end\n end",
"def connect_using conn\n @connection = conn\n end",
"def initialize(host, **options)\n self.logger = options[:logger]\n\n @reactor = ::Libuv.reactor\n\n @host = host\n @port = options[:port] || DEFAULT_PORT\n @bind_address = options[:bind_address] || '0.0.0.0'\n @options = options\n\n debug { \"establishing connection to #{@host}:#{@port}\" }\n\n actual_host = if IPAddress.valid?(@host)\n @host\n else\n @reactor.lookup(@host)[0][0]\n end\n\n @socket = PacketStream.new(self, **options)\n @socket.connect(actual_host, @port)\n\n debug { \"connection established\" }\n\n @host_key_verifier = select_host_key_verifier(options[:paranoid])\n @algorithms = Algorithms.new(self, options)\n @server_version = ServerVersion.new\n @socket.algorithms = @algorithms\n\n socket.direct_write \"#{::Net::SSH::Transport::ServerVersion::PROTO_VERSION}\\r\\n\"\n socket.start_read\n\n @algorithms.ready # Wait for this to complete\n end",
"def connection\n CryptKeeper::Connection.http_instance\n end",
"def oa_conn(args = nil)\n begin\n args_conn = {\n :oata => self,\n :host => Knj::Opts.get(\"openall_host\"),\n :port => Knj::Opts.get(\"openall_port\"),\n :username => Knj::Opts.get(\"openall_username\"),\n :password => Base64.strict_decode64(Knj::Opts.get(\"openall_password\")),\n :ssl => Knj::Strings.yn_str(Knj::Opts.get(\"openall_ssl\"), true, false)\n }\n args_conn.merge!(args) if args\n \n conn = Openall_time_applet::Connection.new(args_conn)\n yield(conn)\n ensure\n conn.destroy if conn\n end\n end",
"def connect!\n @ssh = Net::SSH.start(@host, @user, :password => @pass)\n end",
"def connect(t = -1)\n # If we already have a connection and we aren't pipelining, close it.\n if (self.conn)\n if !pipelining?\n close\n else\n return self.conn\n end\n end\n\n timeout = (t.nil? or t == -1) ? 0 : t\n\n self.conn = Rex::Socket::Tcp.create(\n 'PeerHost' => self.hostname,\n 'PeerPort' => self.port.to_i,\n 'LocalHost' => self.local_host,\n 'LocalPort' => self.local_port,\n 'Context' => self.context,\n 'SSL' => self.ssl,\n 'SSLVersion' => self.ssl_version,\n 'Proxies' => self.proxies,\n 'Timeout' => timeout\n )\n end",
"def connect_to_server\n fail \"connect_server called without remote established\" if @remote.nil?\n host, port = @remote\n LOGGER.info \"Establishing new connection with #{host}:#{port}\"\n @server_side = ServerConnection.request(host, port, self)\n @server_side.pending_connect_timeout = @connect_timeout\n @server_side.comm_inactivity_timeout = @inactivity_timeout\n end",
"def connect()\n @sock = TCPSocket.open(@server, @port)\n end",
"def run\n require 'client'\n\n begin\n client = Client.new params[:address].value, params[:port].value\n puts \"Connected to Chain Reactor server, version #{client.version}\"\n data_input = params[:data].value\n\n if data_input\n client.send(data_input.gets.strip)\n else\n client.send_as_json(get_hash_from_stdin)\n client.close()\n end\n exit_status exit_success\n rescue ClientError => e\n STDERR.puts e.message\n exit_status exit_failure\n rescue SystemExit, Interrupt\n STDERR.puts \"Caught exit signal\" \n exit_status exit_failure\n rescue Exception => e\n STDERR.puts \"An error occured {#{e.class.name}}: #{e.message}\" \n exit_status exit_failure\n end\n end",
"def connect\n @socket = TCPSocket.new(@domain, @port)\n @parser = Jabber::Protocol.Parser.new(socket, self)\n\n register_parsing_thread\n register_polling_thread\n\n @status = CONNECTED\n end",
"def connect\n @connection_manager.connect\n return self\n end",
"def start\n raise 'Cannot start a peer pool twice.' if started\n logger.debug 'Start connecting other pears.'\n addr_list = peer_discovery.peers\n\n connect(addr_list)\n\n @started = true\n end",
"def open(ipaddress=\"localhost\", port=23, username=\"alien\", password=\"password\")\n\t\t@con_ipaddress = ipaddress\n\t\t@con_port = port\n\t\t@con_username = username\n\t\t@con_password = password\n\t\t\n\t\topenConnection()\n\tend",
"def init\n # Open a socket for the server to connect on.\n @sock = TCPSocket.new(@address , @server.port)\n @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)\n @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, false)\n unless RUBY_PLATFORM =~ /win32/\n @sock.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK)\n end\n c = Connection.new(@server, @sock)\n if c.init\n log.info \"(#{c.object_id}) Connection made.\"\n publish(c)\n true\n else\n false\n end\n rescue Exception\n log.error \"Connector#init\"\n log.error $!\n false\n end",
"def connect_to_server\n @service.connect(connect_settings)\n end",
"def connect\n\t\[email protected]\n\n\t\t# Set up our input and output exchange/queue\n\t\t@output = @client.exchange( @playername, :passive => false )\n\t\t@queue = @client.queue\n\n\t\t@exchange = @client.exchange( @playername, :passive => false )\n\t\t@queue = @client.queue( \"#{@playername}_output\", :exclusive => true )\n\n\t\tlogin_exchange = @client.exchange( 'login', :type => :direct, :auto_delete => true )\n\n\t\t# Set up the queue to handle incoming connections\n\t\tself.log.debug \" setting up the connections queue...\"\n\t\t@connect_queue = @playersbus.queue( 'connections', :exclusive => true )\n\t\t@connect_queue.bind( @login_exch, :key => :character_name )\n\t\t@connect_queue.subscribe(\n\t\t\t:header => true,\n\t\t\t:consumer_tag => 'engine',\n\t\t\t:exclusive => true,\n\t\t\t:no_ack => false,\n\t\t\t&self.method(:handle_connect_event)\n\t\t )\n\tend",
"def connection\n @connection ||= make_connection\n end",
"def create_new_connection(options, &block)\n cleanup!\n @connection_options = options\n @connection = Kitchen::Transport::Ssh::Connection.new(options, &block)\n end",
"def connection\n @connection ||= @ar_client.instance_variable_get(\"@connection\")\n end",
"def connect\n TCPSocket.open(@host, @port)\n end",
"def initialize\n @connection = Bunny.new\n @connection.start\n @channel = @connection.create_channel\n end",
"def ra_connection\n @_ra_connection ||= HTTP::CardsServiceConnection.new(\n self.access_token,\n self.ra_service_url\n )\n end",
"def establish_connection\n @connection = Net::POP3.new(@server, @port)\n @connection.enable_ssl(OpenSSL::SSL::VERIFY_NONE) if @ssl\n @connection.start(@username, @password)\n end",
"def connect\n Drone::Client.connect\n end",
"def connect\n service\n end",
"def attempt_connection\n @connection_future = Concurrent::Future.new do\n Roby::DRoby::Logfile::Client.new(host, port)\n end\n connection_future.execute\n end"
] | [
"0.65165484",
"0.6503018",
"0.6361423",
"0.63182664",
"0.6288404",
"0.6281889",
"0.62625355",
"0.62207127",
"0.61796784",
"0.6151615",
"0.60898405",
"0.6034493",
"0.60091716",
"0.5935398",
"0.5919064",
"0.5916248",
"0.5912539",
"0.5912539",
"0.5895548",
"0.58930236",
"0.5874377",
"0.5864293",
"0.5857243",
"0.58494043",
"0.5843644",
"0.5817611",
"0.58093894",
"0.58043045",
"0.5798831",
"0.57828015",
"0.5728383",
"0.572644",
"0.57015157",
"0.56981826",
"0.56974125",
"0.5695166",
"0.5694459",
"0.56636053",
"0.565372",
"0.5650495",
"0.5637158",
"0.5628861",
"0.560028",
"0.55894357",
"0.55735666",
"0.5549698",
"0.55493665",
"0.5513983",
"0.5483506",
"0.54806334",
"0.5479374",
"0.54735744",
"0.5471922",
"0.54631877",
"0.54489315",
"0.54489315",
"0.5446793",
"0.5438317",
"0.5436245",
"0.5435041",
"0.5431823",
"0.54234916",
"0.542322",
"0.5419503",
"0.54167306",
"0.54163194",
"0.5412904",
"0.54049593",
"0.5399789",
"0.53951454",
"0.5387023",
"0.5384465",
"0.5382531",
"0.5381699",
"0.5379917",
"0.5379857",
"0.5377835",
"0.5376532",
"0.53723973",
"0.53719085",
"0.5371773",
"0.5370964",
"0.5370324",
"0.5366164",
"0.53548163",
"0.53535897",
"0.53511804",
"0.5330461",
"0.5327681",
"0.5327495",
"0.5324556",
"0.5321336",
"0.5319469",
"0.53141445",
"0.53069305",
"0.52998984",
"0.5297848",
"0.52977484",
"0.5288707",
"0.5280495"
] | 0.55937105 | 43 |
Tests connectivity with the Riakpb host. | def ping?
rpc.request Util::MessageCode::PING_REQUEST
return rpc.status
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connection\n response = send_api_request(:index)\n response[:returncode]\n end",
"def test_connection\n response = send_api_request(:index)\n response[:returncode]\n end",
"def test_connection\n end",
"def test_conn_1p_0000\n assert @conn.open?\n end",
"def test_connection\n x = execute('test')\n return !x.empty?\n rescue StandardError\n return false\n end",
"def test_connection\n synchronize{|conn|}\n true\n end",
"def test_connection\n call :test_connection\n end",
"def test_connection(ip,port)\n\t\tbegin\n\t\t\tsock = Rex::Socket::Tcp.create(\n\t\t\t\t'PeerHost' => ip,\n\t\t\t\t'PeerPort' => port,\n\t\t\t\t'Timeout' => 1\n\t\t\t\t)\n\t\trescue Rex::ConnectionError\n\t\t\treturn :down\n\t\tend\n\t\tsock.close\n\t\treturn :up\n\tend",
"def attempt_connection\n conn = Puppet.runtime[:http]\n\n response = conn.get(test_uri, headers: test_headers, options: options)\n unless response.code.to_i == expected_code\n Puppet.notice \"Unable to connect to the server or wrong HTTP code (expected #{expected_code}) (#{test_uri}): [#{response.code}] #{response.reason}\"\n return false\n end\n return true\n rescue StandardError => e\n Puppet.notice \"Unable to connect to the server (#{test_uri}): #{e.message}\"\n return false\n end",
"def test_connection\n @connection.bind\n last_operation_result\n end",
"def test_connection\n @connection.bind\n last_operation_result\n end",
"def test_local_core_connection\n \n # Change username, password, host and port in order to test the connection with a different Ensembl db server\n assert_nothing_raised do \n Ensembl::Core::DBConnection.connect('Homo sapiens',56,:username => \"anonymous\",:host => \"ensembldb.ensembl.org\", :port => 5306)\n end\n end",
"def test_connection\n error = nil\n @basic_query_params = {\n :fields => {},\n :start_at => 0,\n :max_results => 1000000000\n }\n begin\n response = @access_client.get('/secure/Dashboard.jspa')\n\n if response.code == '502'\n error = 'Something going wrong in JIRA server side. Please, try later.'\n elsif response.code == '403'\n error = 'Please, check your access rights to JIRA.'\n end\n rescue JIRA::HTTPError\n error = 'Please check your credentials or right URL address for Jira'\n end\n check_for_correct_jira_project(error)\n end",
"def test_should_report_not_connected_when_new\n c = LibSSH.connect 'hostname'\n assert (not c.connected?)\n end",
"def online?\n sock = UDPSocket.new()\n online = false\n begin\n sock.connect('193.0.14.129', 25) # that address is k.root-servers.net\n online = true\n sock.close\n rescue Exception => exception\n puts \"\n------------------------------------------------------------\nCannot bind to socket:\n #{exception}\n\nThis is an indication you have network problems.\nNo online tests will be run!!\n------------------------------------------------------------\n\"\n end\n online\nend",
"def test_connectivity\n data = {'cart_type' => 'standalone'}\n\n response = fetch_url_json(\"/broker/cartlist\", data)\n assert_equal 200, response.code.to_i, error_for(:no_connectivity, $libra_server)\n end",
"def attempt_connection\n conn = Puppet::Network::HttpPool.http_instance(http_server, http_port, use_ssl, verify_peer)\n\n response = conn.get(test_path, test_headers)\n unless response.code.to_i == expected_code\n Puppet.notice \"Unable to connect to the server or wrong HTTP code (expected #{expected_code}) (http#{use_ssl ? 's' : ''}://#{http_server}:#{http_port}): [#{response.code}] #{response.msg}\"\n return false\n end\n return true\n rescue StandardError => e\n Puppet.notice \"Unable to connect to the server (http#{use_ssl ? 's' : ''}://#{http_server}:#{http_port}): #{e.message}\"\n return false\n end",
"def test_billomat_connectivity\n assert Billomat.validate!, \"Testing if we're able to connect to Billomat using the supplied API credentials\"\n end",
"def test_centralized_drb_discovery\n\tDRb.stop_service\n\n\tcentral_tuplespace = TupleSpace.new\n\tDRb.start_service 'druby://localhost:1245', central_tuplespace\n\n\tremote_pid = remote_process do\n\t DRb.stop_service\n\t DRb.start_service\n\t central_tuplespace = DRbObject.new_with_uri('druby://localhost:1245')\n\n\t Distributed.state = ConnectionSpace.new :ring_discovery => false, \n\t\t:discovery_tuplespace => central_tuplespace, :plan => plan\n\tend\n\t@local = ConnectionSpace.new :ring_discovery => false, \n\t :discovery_tuplespace => central_tuplespace, :plan => plan\n Distributed.state = local\n\tassert_has_neighbour { |n| n.name == \"#{Socket.gethostname}-#{remote_pid}\" }\n end",
"def test_ringserver_discovery\n\tDRb.stop_service\n\n\tremote_pid = remote_process do\n\t DRb.start_service\n\t Distributed.state = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan\n\t Distributed.publish :bind => '127.0.0.2'\n\tend\n\n\tDRb.start_service\n @local = ConnectionSpace.new :period => 0.5, :ring_discovery => true, :ring_broadcast => BROADCAST, :plan => plan\n\tDistributed.state = local\n\tDistributed.publish :bind => '127.0.0.1'\n\n\tassert_has_neighbour { |n| n.name == \"#{Socket.gethostname}-#{remote_pid}\" }\n end",
"def test!\n @connection = Connection.new 14000\n @bitcoin = BlockrIo.new true\n end",
"def test_connection_open?\n assert_equal true , @conn.open?\n @conn.disconnect\n assert_equal false, @conn.open?\n end",
"def test_IP_IPOK\r\n msg_out = \"IP #{$dominio_registrado}\"\r\n msg_esperada = \"IPOK #{$ip_registrado}\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def check_connection\n one_wait = 5\n max_wait = 5\n request = Net::HTTP::Get.new('/')\n wait = 0;\n while (wait < max_wait)\n begin\n response = Net::HTTP.start(@url.host, @url.port) {|http|\n http.request(request)\n }\n break if Net::HTTPForbidden === response\n break if Net::HTTPNotFound === response\n break if Net::HTTPSuccess === response\n # When we try to connect to a down server with an Apache proxy, \n # we'll get Net::HTTPBadGateway and get here\n rescue Errno::ECONNREFUSED\n # When we try to connect to a down server without an Apache proxy, \n # such as a dev instance, we'll get here\n end\n sleep one_wait;\n wait += one_wait\n end\n if (wait == max_wait)\n puts(\"-- ERROR: couldn't connect to test host on \" + @url.host.to_s)\n return false\n end\n puts(\"-- SUCCESS: test host is alive !\\n\")\n return true\nend",
"def attempt_connection\n # All that we care about is that we are able to connect successfully via\n # https, so here we're simpling hitting a somewhat arbitrary low-impact URL\n # on the scalemgmt server.\n http = Net::HTTP.new(scalemgmt_server, scalemgmt_port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Get.new(test_path, test_headers)\n request.basic_auth(api_user, api_password)\n\n response = http.request(request)\n unless response.is_a?(Net::HTTPSuccess)\n Puppet.notice \"Unable to connect to scalemgmt server (https://#{scalemgmt_server}:#{scalemgmt_port}): [#{response.code}] #{response.msg}\"\n return false\n end\n true\n rescue Exception => e # rubocop:disable Lint/RescueException\n Puppet.notice \"Unable to connect to scalemgmt server (https://#{scalemgmt_server}:#{scalemgmt_port}): #{e.message}\"\n false\n end",
"def test_conn_1p_0010\n @conn.disconnect\n #\n cha = {:host => \"localhost\"}\n assert_raise Stomp::Error::ProtocolErrorConnect do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)\n end \n #\n chb = {\"accept-version\" => \"1.0\"}\n assert_raise Stomp::Error::ProtocolErrorConnect do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, chb)\n end \n end",
"def test(*args)\n client.ping\n\n { success: true, result: 'Checked API endpoint' }\n rescue Gitlab::PrometheusError => err\n { success: false, result: err }\n end",
"def check_connection( conn )\n\tbegin\n\t\tconn.exec( \"SELECT 1\" )\n\trescue PG::Error => err\n\t\t$stderr.puts \"%p while testing connection: %s\" % [ err.class, err.message ]\n\t\tconn.reset\n\tend\nend",
"def check_in\n defaults = OSX::NSUserDefaults.standardUserDefaults\n server_host = defaults.stringForKey(\"server_host\")\n server_port = defaults.integerForKey(\"server_port\")\n \n drb_url = \"druby://#{server_host}:#{server_port}\"\n \n OSX::NSLog(\"Trying to connect to #{drb_url}\")\n \n @server = DRbObject.new(nil, drb_url)\n @host = DRb.uri.scan(/druby:\\/\\/(.*):\\d*/)[0][0]\n begin\n @server.check_in @host\n OSX::NSLog(\"Connected to server\")\n rescue\n @server = nil\n OSX::NSLog(\"Couldn't connect to server: #{$!}\")\n end\n end",
"def test_wait_for_public_ip\n assert inst.wait_for_public_ip\n end",
"def test_can_get_ping\n get '/ping'\n assert last_response.ok?\n assert_equal 'PONG', last_response.body\n end",
"def check_host\n result = `ping -q -c 2 #{@conn[:host]}`\n # return true or false if exit status is 0\n $?.exitstatus == 0\n end",
"def test_connection_exists\n assert_not_nil @conn\n end",
"def test(*args)\n Gitlab::PrometheusClient.new(prometheus_client).ping\n\n { success: true, result: 'Checked API endpoint' }\n rescue Gitlab::PrometheusClient::Error => err\n { success: false, result: err }\n end",
"def test_connect(standalone = true)\n\tif standalone\n\t start_peers\n\n\t notified = []\n\t local.on_neighbour do |n|\n\t\tnotified << n\n\t end\n\tend\n\n\tassert(local.discovery_thread)\n\n\t# Initiate the connection from +local+\n\tremote_neighbour = local.neighbours.find { true }\n\tengine.execute do\n\t did_yield = nil\n\t Peer.initiate_connection(local, remote_neighbour) do |did_yield|\n\t end\n\n\t # Wait for the remote peer to take into account the fact that we\n\t # try connecting\n\t local.synchronize do\n\t\tremote_id = remote_neighbour.remote_id\n\t\tassert(local.pending_connections[remote_id] ||\n\t\t local.peers[remote_id])\n\t end\n\n\t sleep(1)\n\t local.synchronize do\n\t\tremote_id = remote_neighbour.remote_id\n\t\tassert(@remote_peer = local.peers[remote_id], local.peers)\n\t\tassert_equal(remote_peer, did_yield)\n\t end\n\t assert(remote_peer.connected?)\n\t assert(remote.send_local_peer(:connected?))\n\t assert(remote_peer.link_alive?)\n\t assert(remote.send_local_peer(:link_alive?))\n\n\t did_yield = nil\n\t Peer.initiate_connection(local, remote_neighbour) do |did_yield|\n\t end\n\t assert_equal(remote_peer, did_yield)\n\t assert_equal(remote_peer, Peer.connect(remote_neighbour))\n\tend\n\n\tengine.wait_one_cycle\n\tassert(remote_peer.task.running?)\n\t#assert_raises(ArgumentError) { Peer.initiate_connection(local, remote_neighbour) }\n\tassert(remote_peer.link_alive?)\n\n\tremote_peer.synchro_point\n\tassert(remote_peer.connected?)\n\tassert(remote_peer.task.ready?)\n\n\tassert_equal('remote', remote_peer.remote_name)\n\tassert_equal('remote', remote_peer.local_server.remote_name)\n\tassert_equal('local', remote_peer.local_server.local_name)\n\n\tif standalone\n\t assert_equal(1, notified.size)\n\t assert_equal([remote_neighbour], notified)\n\tend\n end",
"def check_connection\n return\n check = HTTParty.get(\"#{@host}/api/process/check_connection?api_key=#{@api_key}\")\n if check.nil? || check[\"status\"][\"code\"] < 0\n @helper.terminate(\"Script was unable to establish connection with dFlow at #{@host}\")\n end\n end",
"def is_ok?\n return (self.status == HostResult::STATUS_OK)\n end",
"def check_connection\n one_wait = 5\n max_wait = 15\n request = Net::HTTP::Get.new('/selenium-server/')\n wait = 0;\n while (wait < max_wait)\n begin\n response = Net::HTTP.start(@host, @port) {|http|\n http.request(request)\n }\n break if Net::HTTPForbidden === response\n break if Net::HTTPNotFound === response\n break if Net::HTTPSuccess === response\n # When we try to connect to a down server with an Apache proxy,\n # we'll get Net::HTTPBadGateway and get here\n rescue Errno::ECONNREFUSED\n # When we try to connect to a down server without an Apache proxy,\n # such as a dev instance, we'll get here\n end\n sleep one_wait;\n wait += one_wait\n end\n if (wait == max_wait)\n p(\"-- ERROR: couldn't connect to Selenium RC on \" + @host)\n return false\n end\n return true\n end",
"def riak\n @riak ||= Riak::Client.new(host: TestChamber.target_url.split('/').last, pb_port: 8087, protocol: 'pbc')\n end",
"def test_connectivity\n\t\t# Allow real requests.\n\t\tWebMock.allow_net_connect!\n\n\t\t# Initialize a new VLille service and load its status.\n\t\tvl = VLille.new\n\t\tvl.load()\n\n\t\t# Ensure there's something in the result.\n\t\tassert_not_nil vl.center_lat\n\t\tassert_not_nil vl.center_lng\n\t\tassert_not_nil vl.zoom_level\n\t\tassert vl.stations.size > 0\n\n\t\t# Load a station to check for emptiness.\n\t\tstation = vl.stations[0]\n\t\tassert_not_nil station.id\n\t\tassert_not_nil station.name\n\t\tassert_not_nil station.lat\n\t\tassert_not_nil station.lng\n\t\tassert_nil station.address\n\t\tassert_nil station.status\n\t\tassert_nil station.bikes\n\t\tassert_nil station.attachs\n\t\tassert_nil station.payment\n\t\tassert_nil station.last_update\n\n\t\t# Load the station and test we have some data now.\n\t\tstation.load\n\t\tassert_not_nil station.address\n\t\tassert_not_nil station.status\n\t\tassert_not_nil station.bikes\n\t\tassert_not_nil station.attachs\n\t\tassert_not_nil station.payment\n\t\tassert_not_nil station.last_update\n\n\t\t# Disallow real requests.\n\t\tWebMock.disable_net_connect!\n\tend",
"def check_connection\n return\n check = HTTParty.get(\"#{@host}/api/check_connection?api_key=#{@api_key}\")\n if check.nil? || check[\"status\"][\"code\"] < 0\n @helper.terminate(\"Script was unable to establish connection with dFile at #{@host}\")\n end\n end",
"def test_ip_exists\n ip = \"127.0.0.1\"\n client = ChainReactor::ClientConnection.new(mock_socket(ip,\"\"),get_logger)\n assert_equal ip, client.ip\n end",
"def test(ip, options = {})\n timeout = Integer(options[:timeout] || 30)\n target = options[:target] || '8.8.8.8'\n !!exec(\"ping -w #{timeout} -c 1 -I #{ip} #{target}\")\n end",
"def test_port(port)\n !EventMachine::Synchrony::TCPSocket.new('127.0.0.1', port).nil?\nrescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH\n false\nend",
"def test_connection\n @pool.hold {|conn|}\n true\n end",
"def connection_valid?\n if status.untested? or (changed? and (changes.keys & @@status_fields).empty?)\n begin\n test_connection\n status.success!\n rescue => e\n error_str = map_connection_exception_to_error(e)\n status.fail!(error_str)\n end\n end\n status.success?\n end",
"def check_connection( conn )\n begin\n @conn.exec(\"SELECT 1\")\n rescue PG::Error => err\n $stderr.puts \"%p while CHECKING TESTING connection: %s\" % [ err.class, err.message ]\n @conn.reset\n puts \"--------- PG CONNECTION RESETED -------------\"\n end\nend",
"def test_REG_REGOK\r\n msg_out = \"REG macau 10.0.1.28\"\r\n msg_esperada = \"REGOK\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def test_REG_FALHA\r\n msg_out = \"REG lajes \"\r\n msg_esperada = \"FALHA\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def up?(host)\n check = Net::Ping::External.new(host)\n check.ping?\nend",
"def check\n tcp_socket_request\n mark_message \"Ping check to #{host}:#{port} successful\"\n rescue => e\n mark_message \"Error: '#{e}'\"\n mark_failure\n end",
"def verify!\n reconnect! unless active?\n end",
"def test_conn_1p_0030\n @conn.disconnect\n #\n cha = get_conn_headers()\n conn = nil\n assert_nothing_raised do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)\n conn.disconnect\n end\n assert conn.protocol >= Stomp::SPL_11\n end",
"def test_IP_IPFALHA\r\n msg_out = \"IP oslo\"\r\n msg_esperada = \"IPFALHA\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def connection_valid?\n begin\n result = client.call(:fe_dummy).body[:fe_dummy_response][:fe_dummy_result]\n @observations << \"app_server: #{result[:app_server]}, db_server: #{result[:db_server]}, auth_server: #{result[:auth_server]}\"\n result[:app_server] == \"OK\" and result[:db_server] == \"OK\" and result[:auth_server] == \"OK\"\n rescue => e\n @errors << e.message\n @backtrace = e.backtrace\n false\n end\n end",
"def test_IP_FALHA_1\r\n msg_out = \"IPacari\"\r\n msg_esperada = \"FALHA\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def test_conn_1p_0020\n @conn.disconnect\n #\n cha = {:host => \"localhost\", \"accept-version\" => \"1.0\"}\n cha[:host] = \"/\" if ENV['STOMP_RABBIT']\n conn = nil\n assert_nothing_raised do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)\n conn.disconnect\n end\n assert_equal conn.protocol, Stomp::SPL_10\n end",
"def connectable?\n begin; ping; rescue; false; end\n end",
"def reachable?\n ping\n true\n rescue Orocos::ComError\n false\n end",
"def test_IP_FALHA_3\r\n msg_out = \"IP acari lixo\"\r\n msg_esperada = \"FALHA\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def run\n begin\n timeout(config[:timeout]) do\n http = Net::HTTP.new(config[:host], config[:port])\n req = Net::HTTP::Get.new('/pools/nodes/')\n req.basic_auth config[:user], config[:password]\n res = http.request(req)\n case res.code\n when /^2/\n ok \"Can get node status\"\n else\n critical res.code\n end\n end\n rescue Timeout::Error\n critical \"Connection timed out\"\n rescue => e\n critical \"Connection error: #{e.message}\"\n end\n end",
"def test_conn_1p_0015\n @conn.disconnect\n #\n cha = {:host => \"localhost\"}\n hash = { :hosts => [ \n {:login => user, :passcode => passcode, :host => host, :port => port, :ssl => nil},\n ],\n :reliable => true, # Note, issue #57 discussion\n :connect_headers => cha,\n :stompconn => get_stomp_conn(),\n :usecrlf => get_crlf(),\n :initial_reconnect_delay => 0.1,\n :max_reconnect_delay => 30,\n :use_exponential_back_off => true,\n :back_off_multiplier => 2,\n :max_reconnect_attempts => 10,\n }\n assert_raise Stomp::Error::ProtocolErrorConnect do\n conn = Stomp::Connection.open(hash)\n end\n hash[:connect_headers] = {\"accept-version\" => \"1.1\"}\n assert_raise Stomp::Error::ProtocolErrorConnect do\n conn = Stomp::Connection.open(hash)\n end\n end",
"def test\n base_url = url_for(path: '')\n logger.debug \"Testing the #{fqdn} fora\"\n client.url = base_url.to_s\n begin\n # this is network library code; it MUST be rescued\n client.perform\n if client.response_code >= 300\n logger.error \"HTTP code not as expected! (#{client.response_code})\"\n end\n rescue => e\n # log the problem and move on\n logger.fatal \"#{e.class}: #{e.message} (#{e.backtrace[0]})\"\n end\n logger.info client.status.to_s\n logger.debug client.header_str.to_s\n # REVIEW: this netcode might need to be rescued\n driver.get base_url.to_s\n logger.info \"#{driver.title} (#{base_url})\"\n logger.debug \"Cookies:\\n\" + cookies.map { |cookie| \"\\t#{cookie[:name]} => #{cookie[:value]}\" }.join(\"\\n\")\n end",
"def get_testrail_connection()\n @tr_con = nil\n @tr_case_types = nil\n @tr_case_fields = nil\n\n print \"Connecting to TestRail system at:\\n\"\n print \"\\tURL : #{$my_testrail_url}\\n\"\n print \"\\tUser : #{$my_testrail_user}\\n\"\n\n # ------------------------------------------------------------------\n # Set up a TestRail connection packet.\n #\n @tr_con = TestRail::APIClient.new($my_testrail_url)\n @tr_con.user = $my_testrail_user\n @tr_con.password = $my_testrail_password\n\n print \"\\nValidated by TestRail system:\\n\"\n print \"\\tUser : #{@tr_con.user}\\n\"\nend",
"def try(host = 'nodeinfo.hype')\n begin\n Timeout::timeout(5) do\n return true if aaaa(host)\n end\n rescue Timeout::Error\n return false\n end\n end",
"def test_ping\n\[email protected](@ping, 0)\n=begin\n\t\tpong = @tt.ping_reply\n\t\tassert_equal(42, pong.length)\n\t\tassert_equal(pong[0, 6], @tt.tap_mac)\n\t\tassert_equal(pong[30, 4], @ping[26, 4])\n\t\tassert_equal(pong[26, 4], @ping[30, 4])\n=end\n\tend",
"def test_ping\n\[email protected](@ping, 0)\n=begin\n\t\tpong = @tt.ping_reply\n\t\tassert_equal(42, pong.length)\n\t\tassert_equal(pong[0, 6], @tt.tap_mac)\n\t\tassert_equal(pong[30, 4], @ping[26, 4])\n\t\tassert_equal(pong[26, 4], @ping[30, 4])\n=end\n\tend",
"def ping\n stats\n true\n rescue Errno::ECONNREFUSED\n false\n end",
"def test_connection_frame\n assert_not_nil @conn.connection_frame\n end",
"def connect_to_roby_interface(\n host, port, retry_connection: false, timeout: nil, retry_period: 0.1\n )\n deadline = Time.now + timeout if retry_connection && timeout\n loop do\n begin\n return Roby::Interface.connect_with_tcp_to(host, port)\n rescue Roby::Interface::ConnectionError => e\n if !retry_connection || (deadline && Time.now > deadline)\n raise\n end\n\n Robot.warn \"failed to connect to #{host}:#{port}: \"\\\n \"#{e.message}, retrying\"\n sleep retry_period\n end\n end\n end",
"def run_tests(sideload_config:)\n telnet_config ={\n 'Host' => @roku_ip_address,\n 'Port' => 8085\n }\n\n loader = Loader.new(**@device_config)\n connection = Net::Telnet.new(telnet_config)\n code, _build_version = loader.sideload(**sideload_config)\n\n if code == SUCCESS\n in_tests = false\n connection.waitfor(@end_reg) do |txt|\n in_tests = handle_text(txt: txt, in_tests: in_tests)\n end\n connection.puts(\"cont\\n\")\n end\n end",
"def test_connect_timeout\n conn = nil\n EM.run do\n conn = EM.connect '192.0.2.0', 80, StubConnection\n conn.pending_connect_timeout = 1\n end\n assert_equal Errno::ETIMEDOUT, conn.error\n end",
"def test(options:)\n get_device do |device|\n loader = Loader.new(config: @config)\n loader.sideload(options: options, device: device)\n linker = Linker.new(config: @config)\n linker.deeplink(options: Options.new(options: {deeplink: \"RunTests:true\"}), device: device)\n\n telnet_config ={\n 'Host' => device.ip,\n 'Port' => 8085\n }\n connection = Net::Telnet.new(telnet_config)\n connection.waitfor(@end_reg) do |txt|\n handle_text(txt: txt)\n end\n print_logs\n connection.puts(\"cont\\n\")\n end\n end",
"def report_connectivity(controller, port, connectivity_map)\n me = `hostname`.chomp\n req = Net::HTTP::Post.new(\"/#{me}\", initheader = {'Content-Type'=>'application/json'})\n req.body = connectivity_map.to_json\n response = Net::HTTP.start(controller, port) do |http|\n http.request(req)\n end\n response.code == '200'\nend",
"def testGetSubscribersOtp_NotConnected()\n topic = \"_GetSubscribers_NotConnected\"\n conn = Scalaris::PubSub.new()\n conn.close_connection()\n #assert_raise( Scalaris::ConnectionError ) { conn.get_subscribers(@testTime.to_s + topic) }\n conn.get_subscribers(@testTime.to_s + topic)\n conn.close_connection()\n end",
"def test_connection\n args = get_connection_args(\"#{endpoint}/auth\")\n args[:raw_response] = true\n RestClient::Request.execute(args)\n end",
"def run_tests(sideload_config:)\n telnet_config ={\n 'Host' => @roku_ip_address,\n 'Port' => 8085\n }\n\n @device_config[:init_params] = {\n root_dir: @root_dir\n }\n loader = Loader.new(**@device_config)\n connection = Net::Telnet.new(telnet_config)\n code, _build_version = loader.sideload(**sideload_config)\n if code == SUCCESS\n @device_config[:init_params] = nil\n linker = Linker.new(**@device_config)\n linker.launch(options: \"RunTests:true\")\n\n connection.waitfor(@end_reg) do |txt|\n handle_text(txt: txt)\n end\n print_logs\n connection.puts(\"cont\\n\")\n end\n end",
"def external_interface\r\n begin\r\n UDPSocket.open {|s| s.connect('ping.watirgrid.com', 1); s.addr.last }\r\n rescue\r\n '127.0.0.1'\r\n end\r\n end",
"def test_IP_FALHA_2\r\n msg_out = \"IP \"\r\n msg_esperada = \"FALHA\"\r\n sock = UDPSocket.new\r\n sock.connect($central_ip, $central_porta)\r\n sock.print(msg_out)\r\n msg_in = sock.recvfrom(20)[0]\r\n assert_equal(msg_esperada, msg_in)\r\n end",
"def test_conn_1p_0070\n @conn.disconnect\n #\n cha = get_conn_headers() \n cha[\"heart-beat\"] = \"500,1000\" # Valid heart beat headers\n conn = nil\n assert_nothing_raised do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)\n conn.disconnect\n end\n assert conn.hbsend_interval > 0\n assert conn.hbrecv_interval > 0\n end",
"def test_conn_1p_0040\n @conn.disconnect\n #\n cha = get_conn_headers() \n cha[\"heart-beat\"] = \"0,0\" # No heartbeats\n conn = nil\n assert_nothing_raised do\n conn = Stomp::Connection.open(user, passcode, host, port, false, 5, cha)\n conn.disconnect\n end\n assert conn.protocol >= Stomp::SPL_11\n end",
"def connect!\n # Keep existing connections\n return unless @backend.nil?\n\n @backend = train_connection.connection\n @backend.wait_until_ready\n\n # When the testing function `mock_instance` is used, it will set\n # this instance variable to false and handle this function call\n # after the platform data is mocked; this will allow binding\n # of mixin functions based on the mocked platform.\n mix_in_target_platform! unless @mocked_connection\n rescue Train::UserError => e\n raise ConnectionFailure.new(e, config)\n rescue Train::Error => e\n # These are typically wrapper errors for other problems,\n # so we'll prefer to use e.cause over e if available.\n raise ConnectionFailure.new(e.cause || e, config)\n end",
"def connect_to_unit\n puts \"Connecting to '#{@host}...\"\n begin\n tcp_client = TCPSocket.new @host, @port\n @ssl_client = OpenSSL::SSL::SSLSocket.new tcp_client, @context\n @ssl_client.connect\n rescue Exception => e\n puts \"Could not connect to '#{@host}: #{e}\"\n end\n end",
"def attempt_connection\n begin\n response = Net::HTTP.get_response(uri)\n unless response.code == \"200\"\n Puppet.notice \"HTTP request (#{uri}) failed: (#{response.code} #{response.body})\"\n return false\n end\n return true\n rescue Errno::ECONNREFUSED => e\n Puppet.notice \"Unable to establish HTTP connection to '#{uri}'; #{e}\"\n return false\n end\n end",
"def run_host(ip)\n\t\tbegin\n\t\t\ts = connect(false)\n\t\t\tdata = s.get\n\t\t\tdisconnect(s)\n\t\trescue ::Rex::ConnectionError, ::EOFError\n\t\t\treturn\n\t\trescue ::Exception\n\t\t\tprint_error(\"Error: #{$!}\")\n\t\t\treturn\n\t\tend\n\n\t\toffset = 0\n\n\t\tl0, l1, l2 = data[offset, 3].unpack('CCC')\n\t\tlength = l0 | (l1 << 8) | (l2 << 16)\n\n\t\t# Read a bad amount of data\n\t\treturn if length != (data.length - 4)\n\n\t\toffset += 4\n\n\t\tproto = data[offset, 1].unpack('C')[0]\n\n\t\t# Application-level error condition\n\t\tif proto == 255\n\t\t\toffset += 2\n\t\t\terr_msg = Rex::Text.to_hex_ascii(data[offset..-1].to_s)\n\t\t\tprint_status(\"#{rhost}:#{rport} is running MySQL, but responds with an error: #{err_msg}\")\n\t\t\treport_service(\n\t\t\t\t:host => rhost,\n\t\t\t\t:port => rport,\n\t\t\t\t:name => \"mysql\",\n\t\t\t\t:info => \"Error: #{err_msg}\"\n\t\t\t)\n\t\telse\n\t\t\toffset += 1\n\t\t\tversion = data[offset..-1].unpack('Z*')[0]\n\t\t\tprint_status(\"#{rhost}:#{rport} is running MySQL #{version} (protocol #{proto})\")\n\t\t\treport_service(\n\t\t\t\t:host => rhost,\n\t\t\t\t:port => rport,\n\t\t\t\t:name => \"mysql\",\n\t\t\t\t:info => version\n\t\t\t)\n\t\tend\n\tend",
"def ping()\n #This is a stub, used for indexing\n end",
"def connect(host = DEFAULT_HOST, port = DEFAULT_PORT)\n self.socket = create_socket(host, port)\n\n identify\n\n remote_host = socket.peeraddr[3]\n remote_port = socket.peeraddr[1]\n\n logger.info(\"Connected to #{remote_host}:#{remote_port}.\")\n return true\n rescue Errno::ECONNREFUSED\n logger.error('Connection refused! Is the Broker running?')\n return false\n end",
"def check_server\n raise Exception.new(\"Could not reach Apocalypse server please check the address and port and try again.\") unless server_reachable?\n end",
"def ping\n @conn.ping\n end",
"def ping\n true\n end",
"def connection(host)\n RobotArmy::GateKeeper.shared_instance.connect(host)\n end",
"def setup\n puts \"Starting test\"\n TRConnector.instance.start\n sleep(1)\n end",
"def ensure_device_status\n\n $test_logger.log(\"Inside ensure_device_status for Thrift Protocol\")\n\n max_retry = 5\n retry_count = 0\n @is_reconnected = false \n begin\n begin\n #Increment current retry\n retry_count += 1\n\n $test_logger.log(\"Ensure device status for MA1000! trial = '#{retry_count}'\")\n\n #Reset connection after second trial onwards\n if retry_count > 1\n reset_connection\n elsif [email protected]?\n #Connect to device if transport is not open\n connect_to_device\n end\n\n #Initialize retry flag to false\n to_retry = false\n\n #Sending check status cmd\n begin\n #Ping data\n ping_data = \"\\x7\\x45\\x67\\x50\"\n\n #Ping and check terminal status\n ping_res = call_thrift{terminal_echo(ping_data)}\n\n $test_logger.log \"Ping reply '#{Common.unpackbytes(ping_res)}'\"\n\n raise \"Ping response mismatch! Expected='#{Common.unpackbytes(ping_data)}', Actual='#{Common.unpackbytes(ping_res)}'\" if ping_res != ping_data\n rescue Exception => ex\n raise(ex, \"Error while checking terminal status!\\n#{ex.message}\", ex.backtrace)\n end\n\n #Handle exception\n rescue Exception => main_ex\n \n @is_reconnected = true\n \n #Raise exception in case of max trials\n raise(main_ex, \"Error while re-connecting to terminal!\\n#{main_ex.message}\", main_ex.backtrace) if retry_count >= max_retry\n\n #Log error\n $test_logger.log_e(\"Could not ensure terminal connection! Trial = '#{retry_count}/#{max_retry}'\", main_ex)\n\n #Set to_retry flag\n to_retry = true\n\n #Wait for 5 seconds before reconnecting\n sleep 5\n end\n\n end while(to_retry)\n\n end",
"def testReplicatedDHT1()\n rdht = Scalaris::ReplicatedDHT.new()\n rdht.close_connection()\n end",
"def testReplicatedDHT1()\n rdht = Scalaris::ReplicatedDHT.new()\n rdht.close_connection()\n end",
"def test_ping_basic\n @tt.sock.send(@ping, 0)\n pong = @tt.ping_reply\n assert_equal(42, pong.length)\n assert_equal(pong[0, 6], @tt.tap_mac)\n assert_equal(pong[30, 4], @ping[26, 4])\n assert_equal(pong[26, 4], @ping[30, 4])\n end",
"def ping\n end",
"def ping(host)\n begin\n Timeout.timeout(5) do\n s = TCPSocket.new(host, 'echo')\n s.close\n return true\n end\n rescue Errno::ECONNREFUSED\n return true\n rescue Timeout::Error, Errno::ENETUNREACH, Errno::EHOSTUNREACH\n return false\n end\n end",
"def run_frankenstein_test(host, port)\n init host, port\n start_test @@test_dir == \"\" ? @test_name : @@test_dir + \"/\" + @test_name\n test\n finish_test\n puts @test_name + \" : \" + (@test_status == \"P\" ? \"Passed\" : \"Failed\")\n @test_status\n end",
"def external_interface\r\n begin\r\n UDPSocket.open {|s| s.connect('ping.watirgrid.com', 1); s.addr.last }\r\n rescue\r\n '127.0.0.1'\r\n end\r\n end",
"def ping(host)\n begin\n Timeout.timeout(5) do\n s = TCPSocket.new(host, 'echo')\n s.close\n return true\n end\n rescue Errno::ECONNREFUSED\n return true\n rescue Timeout::Error, Errno::ENETUNREACH, Errno::EHOSTUNREACH\n return false\n end\nend"
] | [
"0.6756367",
"0.6756367",
"0.6638944",
"0.65829134",
"0.65554047",
"0.6508153",
"0.6396695",
"0.6356738",
"0.6287228",
"0.6275995",
"0.6275995",
"0.62727135",
"0.6268059",
"0.62204564",
"0.62169874",
"0.61831933",
"0.6170404",
"0.61594516",
"0.6050791",
"0.6025588",
"0.60227275",
"0.60205424",
"0.5982097",
"0.5968555",
"0.5967243",
"0.59268004",
"0.59110814",
"0.5906757",
"0.5904158",
"0.5900457",
"0.58795655",
"0.58677024",
"0.5863035",
"0.5847009",
"0.58338964",
"0.58279616",
"0.58147264",
"0.5813058",
"0.5812993",
"0.58044267",
"0.5799274",
"0.57978815",
"0.5789825",
"0.5788826",
"0.5775757",
"0.5767948",
"0.57647026",
"0.57288456",
"0.5703825",
"0.56969047",
"0.5680282",
"0.5679709",
"0.56788266",
"0.56708884",
"0.5668573",
"0.56543535",
"0.56464624",
"0.5644826",
"0.56321955",
"0.56296587",
"0.5628748",
"0.56262183",
"0.56253916",
"0.5624821",
"0.5621103",
"0.5618146",
"0.5618146",
"0.56041646",
"0.560211",
"0.559798",
"0.5589031",
"0.5587478",
"0.5579557",
"0.55785704",
"0.55714154",
"0.5567085",
"0.55447835",
"0.55292916",
"0.55248255",
"0.5524737",
"0.5519112",
"0.5501107",
"0.54907215",
"0.5489987",
"0.5477863",
"0.5477536",
"0.5475007",
"0.5468981",
"0.5465266",
"0.5462782",
"0.5459397",
"0.54532963",
"0.5451407",
"0.5447619",
"0.5447619",
"0.54457754",
"0.543949",
"0.5435155",
"0.5425048",
"0.54207087",
"0.5418184"
] | 0.0 | -1 |
Retrieves basic information from the riak node. | def info
response = rpc.request Riakpb::Util::MessageCode::GET_SERVER_INFO_REQUEST
@node = response.node
@server_version = response.server_version
{:node => @node, :server_version => @server_version}
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def info\n CouchRest.get \"#{@uri}/\"\n end",
"def info\n request('getinfo')\n end",
"def get_info(jid,node)\n iq = Iq.new(:get,jid)\n iq.from = @stream.jid\n discoinfo = Discovery::IqQueryDiscoInfo.new\n discoinfo.node = node\n iq.add(discoinfo)\n info = {}\n @stream.send_with_id(iq) do |answer|\n identity = answer.query.identity\n info['type'] = identity.type\n info['category'] = identity.category\n info['features'] = answer.query.features\n \n answer.query.each_element('x') { |x|\n info['nodeinformation'] = x\n }\n end\n info\n end",
"def server_info\n {:node => \"riak@#{node.host}\", :server_version => '2.0'}\n end",
"def getinfo\n request :getinfo\n end",
"def getinfo\n @api.request 'getinfo'\n end",
"def info(key)\n data = request_data(:get, uri(key))\n return nil unless data\n if nodes = data[S_NODE][S_NODES]\n nodes.each_with_object({}) do |d, acc|\n info = extract_info(d)\n info.delete(:action)\n acc[info[:key]] = info\n end\n else\n info = extract_info(data)\n info.delete(:action)\n info\n end\n end",
"def info\n IbmCloudRest.get \"#{@uri}/\"\n end",
"def node\n attributes['node']\n end",
"def node\n attributes['node']\n end",
"def get_info\n puts \"#{@title} by #{@author} is #{@status}.\"\n if @description\n puts \"#{@title} description: #{@description}.\"\n end\n end",
"def asterisk_get_info\n get \"asterisk/info\"\n end",
"def get_info\n end",
"def get_info\n end",
"def get_info\n end",
"def node\n @node ||= ArkEcosystem::Client::API::Node.new(@client)\n end",
"def info( opts = {} )\n http_action :get, nil, opts\n end",
"def info\n get(\"/api-info\")\n end",
"def getNodeStatus(node_id) \n cm_url = APP_CONFIG['cm_ip'] + ':' + APP_CONFIG['cm_port'].to_s\n res = HTTParty.get(cm_url+\"/resources/node/\"+ node_id)\n # puts \"status \"+node_id\n # puts res\n return res\n\n end",
"def info\n return Error.new('ID not defined') unless @pe_id\n\n rc = @client.call(HOOK_METHODS[:info], @pe_id, false)\n\n if !OpenNebula.is_error?(rc)\n initialize_xml(rc, 'HOOK')\n rc = nil\n\n @pe_id = self['ID'].to_i if self['ID']\n @name = self['NAME'] if self['NAME']\n end\n\n rc\n end",
"def info\n @info\n end",
"def info()\n #This is a stub, used for indexing\n end",
"def basic_info\n\t\t#Grab some basic info using OID values which should be fairly generic in nature\n\t\ttarget = \"#{@manager.config[:host]}:#{@manager.config[:port]}\"\n\t\tcstring = @manager.config[:community]\n\t\t@snmp_version = @manager.config[:version] #We need this one later for some decisions so setting to class var\n\t\tsys_name = @manager.get_value(\"sysName.0\")\n\t\tsys_descr = @manager.get_value(\"sysDescr.0\")\n\n\t\t#Print out our basic info for user\n\t\tputs \"[*] \".light_green + \"Target\".light_yellow + \": #{target}\".white\n\t\tputs \"[*] \".light_green + \"Community String\".light_yellow + \": #{cstring}\".white\n\t\tif @snmp_version\n\t\t\tputs \"[*] \".light_green + \"SNMP Version\".light_yellow + \": #{@snmp_version}\".white\n\t\telse\n\t\t\tprint_caution(\"Unable to determine SNMP Version in use?\")\n\t\tend\n\t\tif sys_name\n\t\t\tputs \"[*] \".light_green + \"System Name\".light_yellow + \": #{sys_name}\".white\n\t\telse\n\t\t\tprint_error(\"Unable to determine system name!\")\n\t\tend\n\t\tif sys_descr\n\t\t\tputs \"[*] \".light_green + \"System Description\".light_yellow + \": \\n#{sys_descr}\".white\n\t\telse\n\t\t\tprint_error(\"Unable to find system description!\")\n\t\tend\n\t\tif @sys_time\n\t\t\tputs \"[*] \".light_green + \"System Uptime\".light_yellow + \": #{@sys_time}\".white\n\t\telse\n\t\t\tprint_error(\"Unable to find system description!\")\n\t\tend\n\tend",
"def getmininginfo\n @api.request 'getmininginfo'\n end",
"def info() \n \treturn self.response.info()\n\tend",
"def gather_nodeinfo\n n = run_context.node\n runlist_roles = n.run_list.select { |item| item.type == :role }.map(&:name)\n runlist_recipes = n.run_list.select { |item| item.type == :recipe }.map(&:name)\n {\n node: n.name,\n os: {\n release: n['platform_version'],\n family: n['platform'],\n },\n environment: n.environment,\n roles: runlist_roles,\n recipes: runlist_recipes,\n }\n end",
"def info\n @info\n end",
"def info\n get '/'\n end",
"def info\n @info\n end",
"def info; end",
"def info; end",
"def healthinfo_doc\n begin\n timeout(3) do\n return XML::Parser.string(open(\"#{@@rn_url}#{params[:id]}\").read).parse() \n end\n rescue Exception\n return nil\n rescue Timeout::Error\n return nil\n end\n end",
"def info()\n return nil\n end",
"def info\n @info ||= client.try(:get, transaction_url)||{}\n end",
"def info\n nil\n end",
"def disco_info(node = nil)\n disco_for(:info, node)\n end",
"def node\n publish[:node]\n end",
"def index\n @node = Fedora.rest('rest/')\n end",
"def get_node_data()\n return @node_data\n end",
"def info\n info = Hash.new\n output = @filer.invoke(\"system-get-info\")\n if(output.results_errno() != 0)\n r = output.results_reason()\n raise \"Failed : \\n\" + r\n else \n output.children_get[0].children_get.each do |naelem|\n info[naelem.name] = naelem.content\n end\n end\n info\n end",
"def getblockchaininfo\n @api.request 'getblockchaininfo'\n end",
"def info\n response = from_server \"api/info.json\"\n response.data\n end",
"def get(\n id,\n deadline: nil\n )\n req = V1::NodeGetRequest.new()\n if not @parent.snapshot_time.nil?\n req.meta = V1::GetRequestMetadata.new()\n req.meta.snapshot_at = @parent.snapshot_time\n end\n\n req.id = (id)\n tries = 0\n plumbing_response = nil\n loop do\n begin\n plumbing_response = @stub.get(req, metadata: @parent.get_metadata(\"Nodes.Get\", req), deadline: deadline)\n rescue => exception\n if (@parent.shouldRetry(tries, exception))\n tries + [email protected](tries)\n next\n end\n raise Plumbing::convert_error_to_porcelain(exception)\n end\n break\n end\n\n resp = NodeGetResponse.new()\n resp.meta = Plumbing::convert_get_response_metadata_to_porcelain(plumbing_response.meta)\n resp.node = Plumbing::convert_node_to_porcelain(plumbing_response.node)\n resp.rate_limit = Plumbing::convert_rate_limit_metadata_to_porcelain(plumbing_response.rate_limit)\n resp\n end",
"def get_raw_information\n @infos[RAW]\n end",
"def information\n @information || grab_information_without_download\n end",
"def info\n return @info\n end",
"def info\n @info ||= {}\n end",
"def get_basic_account_info\n body = {cmd: \"get_basic_info\"}\n post body\n end",
"def get_rover_details; end",
"def get_info\n \"here is some info on#{self.name}: #{self.about}\"\n end",
"def method_missing(method, *args, &block)\n get_node.send(method, *args, &block)\n end",
"def get_info\n puts @name + ' [ID: ' + @id.to_s + ' @ '+ @@company + ']'\n end",
"def info\n @info ||= {}\n end",
"def node\n items_node[:node]\n end",
"def info\n\tend",
"def getinfo\n coind.getinfo\n end",
"def fetch_basic_info\n {\n server: Socket.gethostname,\n rails_root: defined?(Rails) ? Rails.root : nil,\n process: $PROCESS_ID,\n uname: Sys::Uname.uname,\n timestamp: @timestamp,\n pwd: File.expand_path($PROGRAM_NAME)\n }\n end",
"def node_info()\n node.each do |k,v|\n if \"#{v.class}\" == \"Chef::Node::ImmutableArray\" || \"#{v.class}\" == \"Chef::Node::ImmutableMash\"\n puts \"[#{k}]\"\n v.each do |x,y|\n puts \"\\t#{x}\\t#{y}\"\n end\n else\n puts \"[#{k}]\\t#{v}\"\n end\n puts\n end\nend",
"def show\n puts \"ID = #{@id}\"\n puts \"Node name = #{@name}\"\n puts \"Require's input = #{@require_input}\"\n puts \"Type = #{@type}\"\n puts \"Points at => #{@points_at.pretty_inspect}\"\n end",
"def get_node_details(name_list)\n rpc_get_facts_direct(name_list)\n end",
"def show\n get_node_and_network(params[:id] || params[:name])\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @node }\n format.json { render :json => (params[:key].nil? ? @node : @node[params[:key]]) }\n end\n end",
"def extract_node_details(node)\n item = node\n url = item.url\n caption = item.caption\n selected = active_node?(node)\n [caption, url, selected ]\n end",
"def node_info(client)\n client.send_message('DOM.describeNode', objectId: @object_id)\n end",
"def info(cmd = nil)\n on_each_node :info, cmd\n end",
"def account_info()\n response = @session.do_get build_url(\"/account/info\")\n parse_response(response)\n end",
"def info\n fill_usage_info\n end",
"def get_node_profile\n rpc_get_fact_direct('node_profile')\n end",
"def node\n @node ||= RestClient::Resource.new(url, CloudCrowd.client_options)\n end",
"def info(*args)\n argv = to_pointer([\"info\"] + args)\n ptr = result_ptr = rrd_info(args.size+1, argv)\n\n info = {}\n while result_ptr.address != 0\n item = RRD::Wrapper::RRDInfo.new result_ptr\n info[item[:key]] = item[:value][INFO_TYPE[item[:type]].to_sym]\n result_ptr = item[:next]\n end\n\n rrd_info_free(ptr)\n\n return false if info.empty?\n info\n\n ensure\n free_pointers\n end",
"def get_switch_info\n get_uri = @controller.get_node_operational_uri(self)\n response = @controller.rest_agent.get_request(get_uri)\n check_response_for_success(response) do |body|\n general_info = {}\n if body.has_key?('node') && body['node'].is_a?(Array)\n properties = body['node'][0]\n if properties.has_key?('flow-node-inventory:manufacturer')\n general_info['manufacturer'] = properties['flow-node-inventory:manufacturer']\n end\n if properties.has_key?('flow-node-inventory:serial-number')\n general_info['serial-number'] = properties['flow-node-inventory:serial-number']\n end\n if properties.has_key?('flow-node-inventory:software')\n general_info['software'] = properties['flow-node-inventory:software']\n end\n if properties.has_key?('flow-node-inventory:hardware')\n general_info['hardware'] = properties['flow-node-inventory:hardware']\n end\n if properties.has_key?('flow-node-inventory:description')\n general_info['description'] = properties['flow-node-inventory:description']\n end\n NetconfResponse.new(NetconfResponseStatus::OK, general_info)\n else\n NetconfResponse.new(NetconfResponseStatus::DATA_NOT_FOUND)\n end\n end\n end",
"def info\n [@level, @tag, @data]\n end",
"def get\n if @position.access\n data = @node.send(@position.access) \n else\n data = @node\n end\n end",
"def discover_infos(node=nil)\n hash = {'xmlns' => Namespaces::DiscoverInfos}\n hash['node'] = node if node\n iq = connection.iq_stanza({'to'=>jid}, x('query', hash))\n send_iq_stanza_fibered iq\n end",
"def node\n return @node if @node\n Rbeapi::Client.load_config(ENV['RBEAPI_CONF']) if ENV['RBEAPI_CONF']\n connection_name = ENV['RBEAPI_CONNECTION'] || 'localhost'\n @node = Rbeapi::Client.connect_to(connection_name)\n end",
"def details\n data()\n end",
"def cmd_get argv\n setup argv\n e = @hash['element']\n response = @api.get(e)\n msg JSON.pretty_generate(response)\n return response\n end",
"def info(username)\n perform_request({:action => 'reseller-info', :username => username}) && returned_parameters\n end",
"def info(**args)\n valid_params?(args)\n params = convert_params(args)\n client.get(\"#{ENDPOINT}/info\", options: params.compact).tap do |resp|\n resp.body = resp.body.map { |_k, data| data }\n end\n end",
"def info(**args)\n valid_params?(args)\n params = convert_params(args)\n client.get(\"#{ENDPOINT}/info\", options: params.compact).tap do |resp|\n resp.body = resp.body.map { |_k, data| data }\n end\n end",
"def description\n info[\"Description\"]\n end",
"def node_basic_config(node)\n\t\tconfig, service = lib('requirements'), lib('services')\n\t\t{'name' => node, 'selenium-version' => config[\"selenium\"][\"version\"], 'kickstart' => service[\"kickstart-server\"]}\n\tend",
"def node_description\n\t\tdesc = \"%s %s %s/%s\" % [\n\t\t\tself.http_method,\n\t\t\tself.uri,\n\t\t\tself.app_protocol.upcase,\n\t\t\tself.http_version,\n\t\t]\n\n\t\tif body && !body.empty?\n\t\t\tdesc << \" {%s} (%s)\" % [ self.body, self.body_mimetype ]\n\t\tend\n\n\t\tdesc << ' -> %d response' % [ self.expected_status.to_i ]\n\n\t\treturn desc\n\tend",
"def info(action=nil)\n if @info\n case action\n when :update, :sync, :refresh\n @info = @client.my(:info)\n when nil\n @info\n else\n raise ArgumentError, \"#{action} is not a valid argument for @info.\"\n end\n else\n @info = @client.my(:info)\n end\n end",
"def get_info\r\n return @infoxml unless @infoxml.nil?\r\n \r\n response = Net::Flickr.instance().request('flickr.people.getInfo', 'user_id' => @id)\r\n \r\n return @infoxml = response.at('person')\r\n end",
"def get_node_data(url)\n begin\n response = RestClient.get(url,\n authorization: \"Basic #{Base64.strict_encode64(\"#{@username}:#{@password}\")}\",\n content_type: 'application/json',\n accept: 'application/json',\n timeout: 120)\n response_data = JSON.parse(response)\n result = response_data['result'][0]\n\n rescue RestClient::ExceptionWithResponse => e\n e.response\n @logger.err(e.response) unless @logger.nil?\n result = nil\n end\n\n update_attributes(result)\n end",
"def description\n node.at(\"description\").text\n end",
"def info(username)\n perform_request(action: 'reseller-info', username: username) && returned_parameters\n end",
"def attributes\n node[1]\n end",
"def node_type() ; info[:node_type] ; end",
"def node_type() ; info[:node_type] ; end",
"def get_details\n return self if detailed?\n res = client.get(path_base).to_h\n update(res)\n res\n end",
"def raw_info\n @raw_info ||= access_token.get('/api/v1/me').parsed\n end",
"def get!\n load!(etcd.get(etcd_key).node)\n end",
"def get_node\n # @@neo = Neography::Rest.new\n begin\n # qur = \"MATCH (n {object_id: \"+self.id.to_s+\", object_type: \\'\"+self.class.to_s+\"\\' }) RETURN n LIMIT 1\"\n # response = @@neo.execute_query(qur)\n # node_id = response[\"data\"].flatten.first[\"metadata\"][\"id\"]\n node_id = self.get_node_id\n node = (node_id ? Neography::Node.load(node_id, @@neo) : nil)\n return node\n rescue Exception\n return nil\n end\n end",
"def info(key)\n response = request(:get, uri(key))\n if response.status == 200\n data = MultiJson.load(response.body)\n if data.is_a?(Array)\n data.each_with_object({}) do |d, acc|\n info = extract_info(d)\n info.delete(:action)\n acc[info[:key]] = info\n end\n else\n info = extract_info(data)\n info.delete(:action)\n info\n end\n else\n nil\n end\n end",
"def bio\n @data['bio']\n end",
"def print()\n puts @node_data.to_s\n end",
"def read_host_info\n json { execute_prlctl('server', 'info', '--json') }\n end",
"def node\n @node\n end",
"def node\n @node\n end"
] | [
"0.6485314",
"0.63724726",
"0.63476044",
"0.62544376",
"0.62421924",
"0.6230913",
"0.6226347",
"0.61459154",
"0.60947365",
"0.60947365",
"0.60075223",
"0.599211",
"0.59124357",
"0.59124357",
"0.59124357",
"0.5871939",
"0.5860016",
"0.57710177",
"0.5753367",
"0.57347697",
"0.573095",
"0.5697268",
"0.56963634",
"0.56558716",
"0.5654203",
"0.5647757",
"0.5642076",
"0.56410515",
"0.56366396",
"0.5621011",
"0.5621011",
"0.56203854",
"0.56045943",
"0.5589531",
"0.5584988",
"0.5508166",
"0.5503091",
"0.55014175",
"0.55010206",
"0.5500888",
"0.549741",
"0.5480585",
"0.547335",
"0.5472336",
"0.5464652",
"0.545178",
"0.5448115",
"0.54459083",
"0.54427224",
"0.5388811",
"0.5383169",
"0.5382283",
"0.5366391",
"0.53645694",
"0.53614825",
"0.53409934",
"0.5340678",
"0.5316365",
"0.5316015",
"0.5306681",
"0.53061825",
"0.5301079",
"0.52989846",
"0.5293906",
"0.52915657",
"0.5291488",
"0.5288845",
"0.52851814",
"0.5284703",
"0.528317",
"0.52766937",
"0.5268639",
"0.52684504",
"0.52607024",
"0.5226607",
"0.5218032",
"0.52177215",
"0.5217267",
"0.5217267",
"0.52149343",
"0.52095914",
"0.5205068",
"0.52047783",
"0.5200365",
"0.5195177",
"0.5184446",
"0.51817495",
"0.51782316",
"0.5174192",
"0.5174192",
"0.51689863",
"0.5163248",
"0.51611024",
"0.5160613",
"0.5154954",
"0.51476616",
"0.51443696",
"0.5126124",
"0.5122432",
"0.5122432"
] | 0.529909 | 62 |
I need bucket! Bring me bucket! (Retrieves a bucket from Riakpb. Eating disorder not included.) | def bucket(bucket)
return(@bucket_cache[bucket]) if @bucket_cache.has_key?(bucket)
self.bucket!(bucket)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucket\n @bucket ||= connection.directories.get(@bucket_name, :prefix => @prefix)\n end",
"def bucket!(bucket)\n request = Riakpb::RpbGetBucketReq.new(:bucket => bucket)\n response = rpc.request(\n Util::MessageCode::GET_BUCKET_REQUEST,\n request\n )\n @bucket_cache[bucket].load(response)\n end",
"def bucket_field\n 'bucket'\n end",
"def bucket\n @gapi[\"bucket\"]\n end",
"def bucket\n @bucket or raise NoBucketSpecified\n end",
"def default_bucket\n request(method: :get, path: '/v1/buckets')\n end",
"def bucket; ::AWS::S3.new( { :secure => false } ).buckets[DC::SECRETS['bucket']]; end",
"def bucket\n begin\n # Find existing bucket:\n bucket = service.buckets.find(s3_bucket)\n rescue ::S3::Error::NoSuchBucket => e\n # Apparently the bucket doesn't exist yet, so create a new one:\n bucket = service.buckets.build(s3_bucket)\n bucket.save\n end\n bucket.retrieve\n end",
"def bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def get bucket=nil\n if bucket\n super [@resource , bucket].join('/') \n else \n super\n end\n end",
"def newBucket\n innerNewBucket \n end",
"def bucket(bucket)\n @buckets[bucket] = RiakOdm::Bucket.new(self, bucket) unless @buckets.has_key? bucket\n @buckets[bucket]\n end",
"def get_bucket(bucket_name, options={})\n resp = get(bucket_name, '/', options)\n resp_obj = Crack::XML.parse(resp.body)\n if resp.code == \"200\"\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket retrieved successfully\"\n contents = resp_obj[\"ListBucketResult\"][\"Contents\"] ? Array.new : nil\n resp_obj[\"ListBucketResult\"][\"Contents\"].is_a?(Array) ? \\\n (contents = resp_obj[\"ListBucketResult\"][\"Contents\"]) : \\\n (contents[0] = resp_obj[\"ListBucketResult\"][\"Contents\"]) unless contents.nil?\n resp_obj[:contents] = contents\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :raw].include?(key) }\n\n else\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"]\n resp_obj[:contents] = nil\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :code, :raw].include?(key) }\n\n end\n return resp_obj\n end",
"def get_bucket(name)\n Bucket.new({:name => name}, @protocol)\n end",
"def bucket; ::AWS::S3.new({ secure: true }).buckets[DC::SECRETS['bucket']]; end",
"def list_my_buckets(s3)\n resp = s3.list_buckets()\n puts \"My buckets now are:\\n\\n\"\n\n resp.buckets.each do |bucket|\n puts bucket.name\n end\n\nend",
"def list_my_buckets(s3)\n resp = s3.list_buckets\n puts \"My buckets now are:\\n\\n\"\n\n resp.buckets.each do |bucket|\n puts bucket.name\n end\n\nend",
"def bucket_name\n self.class.bucket.name\n end",
"def find_bucket(name)\n buckets.find(\"#{name}\")\n end",
"def finish\n # Look up our bucket, if there is one\n bucket\n super\n end",
"def bucket(bucket_id)\n @server.bucket(bucket_id)\n end",
"def bucket\n @bucket ||= begin\n bucket = config[:bucket]\n connection.buckets.create(bucket) unless connection.buckets[bucket].exists?\n connection.buckets[bucket]\n end\n end",
"def bucket_for(type)\n return BUCKETS[type.to_sym]\n end",
"def get_bucket(bucket_id:)\n path = '/storage/buckets/{bucketId}'\n .gsub('{bucketId}', bucket_id)\n\n if bucket_id.nil?\n raise Appwrite::Exception.new('Missing required parameter: \"bucketId\"')\n end\n\n params = {\n }\n \n headers = {\n \"content-type\": 'application/json',\n }\n\n @client.call(\n method: 'GET',\n path: path,\n headers: headers,\n params: params,\n response_type: Models::Bucket\n )\n end",
"def get_bucket!(bucket_name, **opts)\n bucket = gcs_client.bucket(bucket_name, **opts)\n return bucket if bucket\n raise BucketNotFoundError.new(\"Bucket \\\"#{bucket_name}\\\" not found\")\n end",
"def s3_bucket(name)\n s3_client.buckets[name]\n end",
"def checkBucket(bucket, client)\n\tbegin\n\t\tresp = client.list_objects({ bucket: bucket })\n\trescue Aws::S3::Errors::NoSuchBucket => err\n\t\t# Catching errors case name informed is wrong\n\t\tputs \"#{err}!\" \n\t\tresp = client.list_buckets\n\t\t# Informe current buckets\n\t\tputs \"Valid buckets currently are: \"\n\t\tresp.buckets.map(&:name).each do |item|\n\t\t\tputs \"=> #{item}\"\n\t\tend\n\t\texit\n\tend\n\treturn resp\nend",
"def aws_S3_bucket_get(opts)\n AWS::S3.new.buckets[opts[:name]]\n end",
"def get_s3_bucket_object(bucket_name)\n resource.bucket(bucket_name)\n end",
"def random_bucket_hash name=random_bucket_name\n {\"kind\"=>\"storage#bucket\",\n \"id\"=>name,\n \"selfLink\"=>\"https://www.googleapis.com/storage/v1/b/#{name}\",\n \"projectNumber\"=>\"1234567890\",\n \"name\"=>name,\n \"timeCreated\"=>::Time.now,\n \"metageneration\"=>\"1\",\n \"owner\"=>{\"entity\"=>\"project-owners-1234567890\"},\n \"location\"=>\"US\",\n \"storageClass\"=>\"STANDARD\",\n \"etag\"=>\"CAE=\" }\n end",
"def find(key, bucket = nil)\n # N.B. This is arguably a hack. From what the current S3 API exposes, when you retrieve a bucket, it\n # provides a listing of all the files in that bucket (assuming you haven't limited the scope of what it returns).\n # Each file in the listing contains information about that file. It is from this information that an S3Object is built.\n #\n # If you know the specific file that you want, S3 allows you to make a get request for that specific file and it returns\n # the value of that file in its response body. This response body is used to build an S3Object::Value object. \n # If you want information about that file, you can make a head request and the headers of the response will contain \n # information about that file. There is no way, though, to say, give me the representation of just this given file the same \n # way that it would appear in a bucket listing.\n #\n # When fetching a bucket, you can provide options which narrow the scope of what files should be returned in that listing.\n # Of those options, one is <tt>marker</tt> which is a string and instructs the bucket to return only object's who's key comes after\n # the specified marker according to alphabetic order. Another option is <tt>max-keys</tt> which defaults to 1000 but allows you\n # to dictate how many objects should be returned in the listing. With a combination of <tt>marker</tt> and <tt>max-keys</tt> you can\n # *almost* specify exactly which file you'd like it to return, but <tt>marker</tt> is not inclusive. In other words, if there is a bucket\n # which contains three objects who's keys are respectively 'a', 'b' and 'c', then fetching a bucket listing with marker set to 'b' will only\n # return 'c', not 'b'. \n #\n # Given all that, my hack to fetch a bucket with only one specific file, is to set the marker to the result of calling String#previous on\n # the desired object's key, which functionally makes the key ordered one degree higher than the desired object key according to \n # alphabetic ordering. This is a hack, but it should work around 99% of the time. I can't think of a scenario where it would return\n # something incorrect.\n \n # We need to ensure the key doesn't have extended characters but not uri escape it before doing the lookup and comparing since if the object exists, \n # the key on S3 will have been normalized\n key = key.remove_extended unless key.valid_utf8?\n bucket = Bucket.find(bucket_name(bucket), :marker => key.previous, :max_keys => 1)\n # If our heuristic failed, trigger a NoSuchKey exception\n if (object = bucket.objects.first) && object.key == key\n object \n else \n raise NoSuchKey.new(\"No such key `#{key}'\", bucket)\n end\n end",
"def find_bucket(object)\n\n\t\tif object == \"song\"\n\t\t\t@bucket = BUCKET\n\t\telsif object == \"album\"\n\t\t\t@bucket = ALBUM_BUCKET\n\t\telsif object == \"image\"\n\t\t\t@bucket = IMAGE_BUCKET\n\t\tend\n\n\tend",
"def object!\n connection.get(\"/#{URI.escape(@key)}\", @bucket_name)\n end",
"def bucket_name\n 'ios-ksr-builds'\nend",
"def bucket(name, options={})\n options.assert_valid_keys(:keys, :props)\n response = http.get(200, prefix, escape(name), {:keys => false}.merge(options), {})\n Bucket.new(self, name).load(response)\n end",
"def google_bucket_url\n \"https://accounts.google.com/AccountChooser?continue=https://console.cloud.google.com/storage/browser/#{self.bucket_id}\"\n end",
"def bucket_name\n returning @bucket_name do |name|\n begin\n Bucket.create(name)\n rescue => e\n #puts \"Error creating bucket: #{e}\"\n end\n end\n end",
"def create_bucket(bucket_key,access_token)\n response = RestClient.post(\"#{API_URL}/oss/v2/buckets\",\n { bucketKey: bucket_key, policyKey:'transient'}.to_json,\n { Authorization: \"Bearer #{access_token}\", content_type:'application/json' })\n return response\nend",
"def bucket_from_uri(uri)\n uri.split('/')[2]\n end",
"def upload_bucket\n ::AWS::S3.new( { :secure => false } ).buckets['s3.documentcloud.org']\n end",
"def find_bucket(bucket)\n begin\n Bucket.find(bucket) \n rescue NoSuchBucket\n S3.create_bucket(bucket)\n find_bucket(bucket)\n end\n end",
"def bucket_with_name(bucket_name)\n @buckets[bucket_name.to_sym] if bucket_name\n end",
"def list_buckets(s3_client)\r\n response = s3_client.list_buckets\r\n if response.buckets.count.zero?\r\n puts 'No buckets.'\r\n else\r\n response.buckets.each do |bucket|\r\n puts bucket.name\r\n end\r\n end\r\nrescue StandardError => e\r\n puts \"Error listing buckets: #{e.message}\"\r\nend",
"def bucket\n return Brevidy::Application::S3_BUCKET\n end",
"def [] bucket_name\n bucket_named(bucket_name)\n end",
"def get_buckets\n buckets = call(CMD_GET_BUCKETS)[:buckets]\n buckets.map {|bucket| Bucket.new(bucket) }\n end",
"def print_bucket(name)\n msg \"#{bucket_name(name)} Bucket\"\n AWS::S3::Bucket.find(bucket_name(name)).objects.each do |o| \n puts \"size: #{o.size/1.megabyte}MB, Name: #{o.key}, Last Modified: #{o.last_modified.to_s(:short)} UTC\"\n end\n rescue AWS::S3::NoSuchBucket\n end",
"def get_aws(name)\n buckets.fetch(name)\n rescue KeyError\n puts \"No S3 bucket named #{name}\"\n exit\n end",
"def list_s3_buckets()\n\n s3 = connect_to_s3()\n response = s3.list_buckets\n\n response.buckets.each do |bucket|\n puts \"#{bucket.creation_date} #{bucket.name}\"\n end\n\nend",
"def s3_bucket\n Lono::S3::Bucket.name\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def full_bucket(bucket_name)\n @monkey_patched ||= monkey_patch_bucket\n @full_buckets ||= Hash.new\n\n bucket = buckets[bucket_name]\n @full_buckets[bucket_name] ||= Aws::S3::Bucket.new(name: bucket_name, client: client(bucket.location))\n end",
"def retrieve_objects_via_http(bucket)\n _log 'Retrieving objects via unauthenticated method.'\n r = http_request :get, \"https://#{bucket}.s3.amazonaws.com\"\n if r.code != '200'\n _log 'Failed to retrieve any objects using the unauthenticated technique as bucket listing is disabled.'\n return\n end\n\n xml_doc = Nokogiri::XML(r.body)\n xml_doc.remove_namespaces!\n results = xml_doc.xpath('//ListBucketResult//Contents//Key').children.map(&:text)\n results[0...999] # return first 1k results as some buckets may have tons of objects\n\n # format before\n results.reject! { |b| b =~ %r{.+/$} } unless results.nil? # remove folder names if bucket_objs is not nil\n results unless results.empty? \n end",
"def find_bucket(bucket_name)\n if bucket = AWS::S3::Bucket.find(bucket_name)\n puts \"Bucket #{bucket_name} found.\"\n bucket\n else\n puts \"The bucket #{bucket_name} could not be found\"\n nil\n end\nend",
"def bucket_meta_objects(bucket_name, *args)\n options = {\n :delimeter => nil,\n :marker => nil,\n :max_keys => nil,\n :prefix => nil\n }\n options.merge!(args.pop) if args.last.is_a? Hash\n\n path = \"/?\"\n path << \"delimeter=#{options[:delimeter]}&\" if !options[:delimeter].nil?\n path << \"marker=#{options[:marker]}&\" if !options[:marker].nil?\n path << \"max-keys=#{options[:max_keys]}&\" if !options[:max_keys].nil?\n path << \"prefix=#{options[:prefix]}&\" if !options[:prefix].nil?\n path.gsub!(/[&]$/, '')\n\n hpr = Hpricot(connection.get(path, bucket_name))\n hpr.search(\"contents\").map do |el|\n BucketMetaObject.new(\n {\n :bucket_name => bucket_name,\n :key => el.search(\"key\").inner_html,\n :last_modified => el.search(\"lastmodified\").inner_html,\n :e_tag => el.search(\"etag\").inner_html,\n :size => el.search(\"size\").inner_html,\n :storage_class => el.search(\"storageclass\").inner_html,\n :owner_id => el.search(\"id\").inner_html,\n :owner_display_name => el.search(\"displayname\").inner_html\n }\n )\n end\n end",
"def bucket\n Replication::IbmProvider.new(\n region: Settings.zip_endpoints.ibm_us_south.region,\n access_key_id: Settings.zip_endpoints.ibm_us_south.access_key_id,\n secret_access_key: Settings.zip_endpoints.ibm_us_south.secret_access_key\n ).bucket\n end",
"def get_workspace_bucket(workspace_bucket_id)\n self.storage.bucket workspace_bucket_id\n end",
"def list\n ::Taxi::S3.instance.list_buckets\n end",
"def bucket_name\n @timestamp + '.' + bucket_base_name\n end",
"def bucket=(bucket)\n @bucket = bucket\n self\n end",
"def s3_bucket\n photo.s3_bucket\n end",
"def buckets\n buckets = self.class.get('/buckets', @options)\n if buckets.has_key?('meta') and buckets.has_key?('data')\n if buckets['meta']['status'] == 'success'\n buckets['data']\n else\n raise RunscopeAPIException.new, buckets['error']\n end\n end\n end",
"def show\n @bucket = Bucket.new\n\n end",
"def bucket_descriptor\n labels = {}\n MU::MommaCat.listStandardTags.each_pair { |name, value|\n if !value.nil?\n labels[name.downcase] = value.downcase.gsub(/[^a-z0-9\\-\\_]/i, \"_\")\n end\n }\n labels[\"name\"] = @mu_name.downcase\n\n params = {\n :name => @mu_name.downcase,\n :labels => labels,\n :storage_class => @config['storage_class'],\n }\n\n if @config['web']\n params[:website] = MU::Cloud::Google.storage(:Bucket)::Website.new(\n main_page_suffix: @config['web_index_object'],\n not_found_page: @config['web_error_object']\n )\n end\n\n if @config['versioning']\n params[:versioning] = MU::Cloud::Google.storage(:Bucket)::Versioning.new(enabled: true)\n else\n params[:versioning] = MU::Cloud::Google.storage(:Bucket)::Versioning.new(enabled: false)\n end\n\n if @config['bucket_wide_acls']\n params[:iam_configuration] = MU::Cloud::Google.storage(:Bucket)::IamConfiguration.new(\n bucket_policy_only: MU::Cloud::Google.storage(:Bucket)::IamConfiguration::BucketPolicyOnly.new(\n enabled: @config['bucket_wide_acls']\n )\n )\n else\n params[:iam_configuration] = MU::Cloud::Google.storage(:Bucket)::IamConfiguration.new(\n bucket_policy_only: MU::Cloud::Google.storage(:Bucket)::IamConfiguration::BucketPolicyOnly.new(\n enabled: false\n )\n )\n end\n\n MU::Cloud::Google.storage(:Bucket).new(params)\n end",
"def buckets\n resp = connection.list_buckets\n if resp.success?\n resp.data[\"items\"].map do |gapi_object|\n Bucket.from_gapi gapi_object, connection\n end\n else\n fail ApiError.from_response(resp)\n end\n end",
"def initialize _bucket, path = ''\n @bucket = _bucket\n @path = path \n end",
"def list_buckets\n s3 = Aws::S3::Client.new(\n region: 'us-east-1'\n )\n resp = s3.list_buckets({})\n # get the total number of buckets\n num_buckets = resp.buckets.length\n # loop through and puts name\n num_buckets.times do |i|\n puts resp.buckets[i].name.colorize(:light_magenta).colorize(:background => :black)\n end\nend",
"def s3_gen_bucket\n s3_gen.bucket(App.aws_bucket,true)\n end",
"def bucket_function\n @bucket_function ||= _bucket_function\n end",
"def print_bucket(name)\n msg \"#{bucket_name(name)} Bucket\"\n make_bucket(name)\n bucket = AWS::S3::Bucket.find(bucket_name(name))\n bucket.each do |object|\n size = object.content_length.to_i\n sizestr = (size > 1.megabyte ? \"#{size/1.megabyte}MB\" : \"#{size/1.kilobyte}KB\")\n puts \"size: #{sizestr}, Name: #{object.key}, Last Modified: #{Time.parse( object.last_modified.to_s ).to_s(:short)} UTC\"\n end\n end",
"def bucket_policy\n @bucket_policy ||= fetch_bucket_policy\n end",
"def bucket(bucket)\n @task.bucket = bucket\n end",
"def bucket_data(bucket, type = nil)\n bucket = bucket.name if Bucket === bucket\n bucket_type_data(type)[:buckets][bucket] ||= {:props => DEFAULT_BUCKET_PROPS.dup, :keys => {}}\n end",
"def get_bucket_logging(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :bucket_name => bucket_name,\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::AWS::Storage::GetBucketLogging.new,\n :query => {'logging' => nil}\n })\n end",
"def buckets\n body = {\n accountId: Backblaze::B2.account_id\n }\n response = post('/b2_list_buckets', body: body.to_json)\n response['buckets'].map do |bucket|\n params = Hash[bucket.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]\n new(params)\n end\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :bucket_name => bucket_name,\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::AWS::Storage::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def each &block\n response = client.list_buckets\n response.buckets.each do |b|\n yield(bucket_named(b.name, response.owner))\n end\n nil\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :host => \"#{bucket_name}.#{@host}\",\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::Storage::AWS::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def get_request(bucket, key, quorum=nil)\n request = Riakpb::RpbGetReq.new({:bucket => bucket, :key => key})\n\n quorum ||= @read_quorum\n unless quorum.blank?\n quorum = quorum.to_i\n request.r = quorum\n end\n\n\n response = rpc.request(\n Util::MessageCode::GET_REQUEST,\n request\n )\n\n return(response)\n end",
"def s3_bucket_by_doc_type\n case document_type\n when \"BVA Case Notifications\"\n \"notification-reports\"\n else\n \"idt-uploaded-documents\"\n end\n end",
"def s3_bucket_by_doc_type\n case document_type\n when \"BVA Case Notifications\"\n \"notification-reports\"\n else\n \"idt-uploaded-documents\"\n end\n end",
"def create_bucket(bucket_key, access_token)\n begin\n response = RestClient.post(\"#{API_URL}/oss/v2/buckets\",\n { bucketKey: bucket_key, policyKey:'transient'}.to_json,\n { Authorization: \"Bearer #{access_token}\", content_type:'application/json' })\n return response\n rescue RestClient::Exception => e\n if e.response.code == 409\n then return 'Bucket already exists'\n else raise e\n end\n end\n end",
"def bucket\n @bucket = AWS::S3.new(:access_key_id => ENV[\"S3_ACCESS_KEY_ID\"], :secret_access_key => ENV[\"S3_SECRET_ACCESS_KEY\"]).buckets[ENV[\"S3_BUCKET\"]] if @bucket.nil?\n @bucket\n end",
"def object_content_by_bucket_unsigned_request(bucket_name, region)\r\n bucket_path = \"https://s3.#{region}.amazonaws.com/#{bucket_name}\"\r\n response = Net::HTTP.get(URI(bucket_path))\r\n puts \"Content of unsigned request to '#{bucket_path}':\\n\\n#{response}\\n\\n\"\r\nend",
"def s3_bucket(bucket, **opt)\n s3_resource(**opt).bucket(bucket)\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n has_authority\n end",
"def initialize\n @bucket = []\n @bucket\n end",
"def list_buckets\n puts '> AWS Buckets'.yellow\n response = s3_client.list_buckets\n buckets = response.buckets.map do |bucket|\n \"#{bucket.name.yellow} - created: #{bucket.creation_date.to_s.greenish}\"\n end\n buckets.each do |bucket|\n puts bucket\n end\n end",
"def create_bucket(bucket_name, options={})\n options[:send_goog_project_id] = true\n resp = put(bucket_name, '/', options)\n if resp.code == \"200\"\n resp_obj = {}\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket created\"\n\n else\n resp_obj = Crack::XML.parse(resp.body)\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"].to_s\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :code, :raw].include?(key) }\n\n end\n return resp_obj\n end",
"def bucket_id bucket_name:\n buckets = b2_list_buckets(bucketName: bucket_name, accountId: account_id).buckets\n found = buckets.find{|hw| hw.bucketName == bucket_name}\n found&.bucketId or raise NotFound, \"no bucket named #{bucket_name}\"\n end",
"def print_bucket_acl bucket_name:\n # [START print_bucket_acl]\n # The ID of your GCS bucket\n # bucket_name = \"your-unique-bucket-name\"\n\n require \"google/cloud/storage\"\n\n storage = Google::Cloud::Storage.new\n bucket = storage.bucket bucket_name\n\n puts \"ACL for #{bucket_name}:\"\n\n bucket.acl.owners.each do |owner|\n puts \"OWNER #{owner}\"\n end\n\n bucket.acl.writers.each do |writer|\n puts \"WRITER #{writer}\"\n end\n\n bucket.acl.readers.each do |reader|\n puts \"READER #{reader}\"\n end\n # [END print_bucket_acl]\nend",
"def create_bucket bucket_name\n resp = connection.insert_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n fail ApiError.from_response(resp)\n end\n end",
"def b2_get_upload_url()\n\n auth_hash = convert_json(b2_authorize_account)\n api_url = auth_hash[\"apiUrl\"]\n account_authorization_token = auth_hash[\"authorizationToken\"]\n bucket_id = ENV['bucket_id']\n\n uri = URI(\"#{api_url}/b2api/v1/b2_get_upload_url\")\n req = Net::HTTP::Post.new(uri)\n req.add_field(\"Authorization\",\"#{account_authorization_token}\")\n req.body = \"{\\\"bucketId\\\":\\\"#{bucket_id}\\\"}\"\n http = Net::HTTP.new(req.uri.host, req.uri.port)\n http.use_ssl = true\n res = http.start {|http| http.request(req)}\n\n case res\n when Net::HTTPSuccess then res.body\n when Net::HTTPRedirection then fetch(res['location'], limit - 1)\n else res.error!\n end\n\nend",
"def remote_file_bucket\n find_or_create_bucket('filestore.platform.infochimps')\n end",
"def list_bucket(bucket, options={}, headers={})\n path_args = {}\n options.each { |k, v|\n path_args[k] = v.to_s\n }\n return generate_url('GET', bucket, '', path_args, headers)\n end",
"def init_buckets\n Hash[client.list_buckets.buckets.map { |bucket| [bucket.name, bucket] }]\n end"
] | [
"0.7721133",
"0.76851845",
"0.7665383",
"0.7629119",
"0.74088997",
"0.7403094",
"0.7271967",
"0.7188265",
"0.71869516",
"0.71458876",
"0.71458876",
"0.71254855",
"0.7082634",
"0.70641756",
"0.70021856",
"0.69898665",
"0.69884795",
"0.6930846",
"0.6918151",
"0.6912644",
"0.6902602",
"0.6900909",
"0.6891708",
"0.68912405",
"0.6800389",
"0.6766746",
"0.67356914",
"0.6728618",
"0.671214",
"0.66993326",
"0.6696871",
"0.6696239",
"0.66936785",
"0.6679803",
"0.6676595",
"0.661545",
"0.6608497",
"0.65538603",
"0.6549943",
"0.6529023",
"0.65275663",
"0.6525137",
"0.6515201",
"0.6503586",
"0.6501838",
"0.64834684",
"0.64820033",
"0.6471748",
"0.6450981",
"0.64346206",
"0.64162225",
"0.6413972",
"0.64043105",
"0.64043105",
"0.64043105",
"0.6401431",
"0.6396217",
"0.639181",
"0.6379117",
"0.6365324",
"0.63220644",
"0.63202226",
"0.6307965",
"0.63057595",
"0.6293612",
"0.627862",
"0.62745625",
"0.6262348",
"0.6261025",
"0.625596",
"0.625123",
"0.62436694",
"0.6239414",
"0.623332",
"0.6222881",
"0.6218584",
"0.6214365",
"0.61935425",
"0.61820537",
"0.6170902",
"0.6158267",
"0.6149876",
"0.61467105",
"0.6145919",
"0.6145919",
"0.61368823",
"0.6135835",
"0.6134238",
"0.6114907",
"0.609741",
"0.6094429",
"0.60883856",
"0.6081763",
"0.6065548",
"0.60650766",
"0.60486764",
"0.60388833",
"0.6034143",
"0.60326856",
"0.602709"
] | 0.6817716 | 24 |
I need bucket! Bring me bucket! (Retrieves a bucket from Riakpb, even if it's already been retrieved.) | def bucket!(bucket)
request = Riakpb::RpbGetBucketReq.new(:bucket => bucket)
response = rpc.request(
Util::MessageCode::GET_BUCKET_REQUEST,
request
)
@bucket_cache[bucket].load(response)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucket\n @bucket ||= connection.directories.get(@bucket_name, :prefix => @prefix)\n end",
"def bucket\n @gapi[\"bucket\"]\n end",
"def bucket\n begin\n # Find existing bucket:\n bucket = service.buckets.find(s3_bucket)\n rescue ::S3::Error::NoSuchBucket => e\n # Apparently the bucket doesn't exist yet, so create a new one:\n bucket = service.buckets.build(s3_bucket)\n bucket.save\n end\n bucket.retrieve\n end",
"def bucket; ::AWS::S3.new( { :secure => false } ).buckets[DC::SECRETS['bucket']]; end",
"def bucket\n @bucket or raise NoBucketSpecified\n end",
"def default_bucket\n request(method: :get, path: '/v1/buckets')\n end",
"def bucket_field\n 'bucket'\n end",
"def bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def get bucket=nil\n if bucket\n super [@resource , bucket].join('/') \n else \n super\n end\n end",
"def bucket; ::AWS::S3.new({ secure: true }).buckets[DC::SECRETS['bucket']]; end",
"def get_bucket(bucket_name, options={})\n resp = get(bucket_name, '/', options)\n resp_obj = Crack::XML.parse(resp.body)\n if resp.code == \"200\"\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket retrieved successfully\"\n contents = resp_obj[\"ListBucketResult\"][\"Contents\"] ? Array.new : nil\n resp_obj[\"ListBucketResult\"][\"Contents\"].is_a?(Array) ? \\\n (contents = resp_obj[\"ListBucketResult\"][\"Contents\"]) : \\\n (contents[0] = resp_obj[\"ListBucketResult\"][\"Contents\"]) unless contents.nil?\n resp_obj[:contents] = contents\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :raw].include?(key) }\n\n else\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"]\n resp_obj[:contents] = nil\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :code, :raw].include?(key) }\n\n end\n return resp_obj\n end",
"def bucket\n @bucket ||= begin\n bucket = config[:bucket]\n connection.buckets.create(bucket) unless connection.buckets[bucket].exists?\n connection.buckets[bucket]\n end\n end",
"def bucket(bucket)\n @buckets[bucket] = RiakOdm::Bucket.new(self, bucket) unless @buckets.has_key? bucket\n @buckets[bucket]\n end",
"def get_bucket!(bucket_name, **opts)\n bucket = gcs_client.bucket(bucket_name, **opts)\n return bucket if bucket\n raise BucketNotFoundError.new(\"Bucket \\\"#{bucket_name}\\\" not found\")\n end",
"def get_bucket(name)\n Bucket.new({:name => name}, @protocol)\n end",
"def get_bucket(bucket_id:)\n path = '/storage/buckets/{bucketId}'\n .gsub('{bucketId}', bucket_id)\n\n if bucket_id.nil?\n raise Appwrite::Exception.new('Missing required parameter: \"bucketId\"')\n end\n\n params = {\n }\n \n headers = {\n \"content-type\": 'application/json',\n }\n\n @client.call(\n method: 'GET',\n path: path,\n headers: headers,\n params: params,\n response_type: Models::Bucket\n )\n end",
"def bucket(bucket)\n return(@bucket_cache[bucket]) if @bucket_cache.has_key?(bucket)\n self.bucket!(bucket)\n end",
"def get_s3_bucket_object(bucket_name)\n resource.bucket(bucket_name)\n end",
"def bucket(bucket_id)\n @server.bucket(bucket_id)\n end",
"def newBucket\n innerNewBucket \n end",
"def find_bucket(name)\n buckets.find(\"#{name}\")\n end",
"def s3_bucket(name)\n s3_client.buckets[name]\n end",
"def object!\n connection.get(\"/#{URI.escape(@key)}\", @bucket_name)\n end",
"def list_my_buckets(s3)\n resp = s3.list_buckets()\n puts \"My buckets now are:\\n\\n\"\n\n resp.buckets.each do |bucket|\n puts bucket.name\n end\n\nend",
"def list_my_buckets(s3)\n resp = s3.list_buckets\n puts \"My buckets now are:\\n\\n\"\n\n resp.buckets.each do |bucket|\n puts bucket.name\n end\n\nend",
"def aws_S3_bucket_get(opts)\n AWS::S3.new.buckets[opts[:name]]\n end",
"def finish\n # Look up our bucket, if there is one\n bucket\n super\n end",
"def bucket_name\n self.class.bucket.name\n end",
"def get_aws(name)\n buckets.fetch(name)\n rescue KeyError\n puts \"No S3 bucket named #{name}\"\n exit\n end",
"def bucket(name, options={})\n options.assert_valid_keys(:keys, :props)\n response = http.get(200, prefix, escape(name), {:keys => false}.merge(options), {})\n Bucket.new(self, name).load(response)\n end",
"def checkBucket(bucket, client)\n\tbegin\n\t\tresp = client.list_objects({ bucket: bucket })\n\trescue Aws::S3::Errors::NoSuchBucket => err\n\t\t# Catching errors case name informed is wrong\n\t\tputs \"#{err}!\" \n\t\tresp = client.list_buckets\n\t\t# Informe current buckets\n\t\tputs \"Valid buckets currently are: \"\n\t\tresp.buckets.map(&:name).each do |item|\n\t\t\tputs \"=> #{item}\"\n\t\tend\n\t\texit\n\tend\n\treturn resp\nend",
"def find_bucket(bucket)\n begin\n Bucket.find(bucket) \n rescue NoSuchBucket\n S3.create_bucket(bucket)\n find_bucket(bucket)\n end\n end",
"def full_bucket(bucket_name)\n @monkey_patched ||= monkey_patch_bucket\n @full_buckets ||= Hash.new\n\n bucket = buckets[bucket_name]\n @full_buckets[bucket_name] ||= Aws::S3::Bucket.new(name: bucket_name, client: client(bucket.location))\n end",
"def google_bucket_url\n \"https://accounts.google.com/AccountChooser?continue=https://console.cloud.google.com/storage/browser/#{self.bucket_id}\"\n end",
"def find(key, bucket = nil)\n # N.B. This is arguably a hack. From what the current S3 API exposes, when you retrieve a bucket, it\n # provides a listing of all the files in that bucket (assuming you haven't limited the scope of what it returns).\n # Each file in the listing contains information about that file. It is from this information that an S3Object is built.\n #\n # If you know the specific file that you want, S3 allows you to make a get request for that specific file and it returns\n # the value of that file in its response body. This response body is used to build an S3Object::Value object. \n # If you want information about that file, you can make a head request and the headers of the response will contain \n # information about that file. There is no way, though, to say, give me the representation of just this given file the same \n # way that it would appear in a bucket listing.\n #\n # When fetching a bucket, you can provide options which narrow the scope of what files should be returned in that listing.\n # Of those options, one is <tt>marker</tt> which is a string and instructs the bucket to return only object's who's key comes after\n # the specified marker according to alphabetic order. Another option is <tt>max-keys</tt> which defaults to 1000 but allows you\n # to dictate how many objects should be returned in the listing. With a combination of <tt>marker</tt> and <tt>max-keys</tt> you can\n # *almost* specify exactly which file you'd like it to return, but <tt>marker</tt> is not inclusive. In other words, if there is a bucket\n # which contains three objects who's keys are respectively 'a', 'b' and 'c', then fetching a bucket listing with marker set to 'b' will only\n # return 'c', not 'b'. \n #\n # Given all that, my hack to fetch a bucket with only one specific file, is to set the marker to the result of calling String#previous on\n # the desired object's key, which functionally makes the key ordered one degree higher than the desired object key according to \n # alphabetic ordering. This is a hack, but it should work around 99% of the time. I can't think of a scenario where it would return\n # something incorrect.\n \n # We need to ensure the key doesn't have extended characters but not uri escape it before doing the lookup and comparing since if the object exists, \n # the key on S3 will have been normalized\n key = key.remove_extended unless key.valid_utf8?\n bucket = Bucket.find(bucket_name(bucket), :marker => key.previous, :max_keys => 1)\n # If our heuristic failed, trigger a NoSuchKey exception\n if (object = bucket.objects.first) && object.key == key\n object \n else \n raise NoSuchKey.new(\"No such key `#{key}'\", bucket)\n end\n end",
"def bucket\n return Brevidy::Application::S3_BUCKET\n end",
"def upload_bucket\n ::AWS::S3.new( { :secure => false } ).buckets['s3.documentcloud.org']\n end",
"def find_bucket(bucket_name)\n if bucket = AWS::S3::Bucket.find(bucket_name)\n puts \"Bucket #{bucket_name} found.\"\n bucket\n else\n puts \"The bucket #{bucket_name} could not be found\"\n nil\n end\nend",
"def bucket_with_name(bucket_name)\n @buckets[bucket_name.to_sym] if bucket_name\n end",
"def bucket_name\n returning @bucket_name do |name|\n begin\n Bucket.create(name)\n rescue => e\n #puts \"Error creating bucket: #{e}\"\n end\n end\n end",
"def bucket_for(type)\n return BUCKETS[type.to_sym]\n end",
"def s3_bucket\n Lono::S3::Bucket.name\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def bucket_from_uri(uri)\n uri.split('/')[2]\n end",
"def get_workspace_bucket(workspace_bucket_id)\n self.storage.bucket workspace_bucket_id\n end",
"def find_bucket(object)\n\n\t\tif object == \"song\"\n\t\t\t@bucket = BUCKET\n\t\telsif object == \"album\"\n\t\t\t@bucket = ALBUM_BUCKET\n\t\telsif object == \"image\"\n\t\t\t@bucket = IMAGE_BUCKET\n\t\tend\n\n\tend",
"def bucket\n @bucket = AWS::S3.new(:access_key_id => ENV[\"S3_ACCESS_KEY_ID\"], :secret_access_key => ENV[\"S3_SECRET_ACCESS_KEY\"]).buckets[ENV[\"S3_BUCKET\"]] if @bucket.nil?\n @bucket\n end",
"def random_bucket_hash name=random_bucket_name\n {\"kind\"=>\"storage#bucket\",\n \"id\"=>name,\n \"selfLink\"=>\"https://www.googleapis.com/storage/v1/b/#{name}\",\n \"projectNumber\"=>\"1234567890\",\n \"name\"=>name,\n \"timeCreated\"=>::Time.now,\n \"metageneration\"=>\"1\",\n \"owner\"=>{\"entity\"=>\"project-owners-1234567890\"},\n \"location\"=>\"US\",\n \"storageClass\"=>\"STANDARD\",\n \"etag\"=>\"CAE=\" }\n end",
"def list_buckets(s3_client)\r\n response = s3_client.list_buckets\r\n if response.buckets.count.zero?\r\n puts 'No buckets.'\r\n else\r\n response.buckets.each do |bucket|\r\n puts bucket.name\r\n end\r\n end\r\nrescue StandardError => e\r\n puts \"Error listing buckets: #{e.message}\"\r\nend",
"def get_buckets\n buckets = call(CMD_GET_BUCKETS)[:buckets]\n buckets.map {|bucket| Bucket.new(bucket) }\n end",
"def bucket_name\n 'ios-ksr-builds'\nend",
"def s3_bucket\n photo.s3_bucket\n end",
"def bucket_policy\n @bucket_policy ||= fetch_bucket_policy\n end",
"def [] bucket_name\n bucket_named(bucket_name)\n end",
"def bucket=(bucket)\n @bucket = bucket\n self\n end",
"def retrieve_objects_via_http(bucket)\n _log 'Retrieving objects via unauthenticated method.'\n r = http_request :get, \"https://#{bucket}.s3.amazonaws.com\"\n if r.code != '200'\n _log 'Failed to retrieve any objects using the unauthenticated technique as bucket listing is disabled.'\n return\n end\n\n xml_doc = Nokogiri::XML(r.body)\n xml_doc.remove_namespaces!\n results = xml_doc.xpath('//ListBucketResult//Contents//Key').children.map(&:text)\n results[0...999] # return first 1k results as some buckets may have tons of objects\n\n # format before\n results.reject! { |b| b =~ %r{.+/$} } unless results.nil? # remove folder names if bucket_objs is not nil\n results unless results.empty? \n end",
"def create_bucket(bucket_key,access_token)\n response = RestClient.post(\"#{API_URL}/oss/v2/buckets\",\n { bucketKey: bucket_key, policyKey:'transient'}.to_json,\n { Authorization: \"Bearer #{access_token}\", content_type:'application/json' })\n return response\nend",
"def s3_bucket(bucket, **opt)\n s3_resource(**opt).bucket(bucket)\n end",
"def bucket\n Replication::IbmProvider.new(\n region: Settings.zip_endpoints.ibm_us_south.region,\n access_key_id: Settings.zip_endpoints.ibm_us_south.access_key_id,\n secret_access_key: Settings.zip_endpoints.ibm_us_south.secret_access_key\n ).bucket\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n has_authority\n end",
"def get_bucket_logging(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :bucket_name => bucket_name,\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::AWS::Storage::GetBucketLogging.new,\n :query => {'logging' => nil}\n })\n end",
"def get(bucket, local_file=nil) # s3://BUCKET/OBJECT LOCAL_FILE\n send_command \"get\", bucket, local_file\n end",
"def buckets\n resp = connection.list_buckets\n if resp.success?\n resp.data[\"items\"].map do |gapi_object|\n Bucket.from_gapi gapi_object, connection\n end\n else\n fail ApiError.from_response(resp)\n end\n end",
"def s3_gen_bucket\n s3_gen.bucket(App.aws_bucket,true)\n end",
"def get_request(bucket, key, quorum=nil)\n request = Riakpb::RpbGetReq.new({:bucket => bucket, :key => key})\n\n quorum ||= @read_quorum\n unless quorum.blank?\n quorum = quorum.to_i\n request.r = quorum\n end\n\n\n response = rpc.request(\n Util::MessageCode::GET_REQUEST,\n request\n )\n\n return(response)\n end",
"def show\n @bucket = Bucket.new\n\n end",
"def buckets\n buckets = self.class.get('/buckets', @options)\n if buckets.has_key?('meta') and buckets.has_key?('data')\n if buckets['meta']['status'] == 'success'\n buckets['data']\n else\n raise RunscopeAPIException.new, buckets['error']\n end\n end\n end",
"def list_s3_buckets()\n\n s3 = connect_to_s3()\n response = s3.list_buckets\n\n response.buckets.each do |bucket|\n puts \"#{bucket.creation_date} #{bucket.name}\"\n end\n\nend",
"def s3_bucket(bucket_name)\n S3Bucket.new(bucket_name)\n end",
"def create_bucket(bucket_key, access_token)\n begin\n response = RestClient.post(\"#{API_URL}/oss/v2/buckets\",\n { bucketKey: bucket_key, policyKey:'transient'}.to_json,\n { Authorization: \"Bearer #{access_token}\", content_type:'application/json' })\n return response\n rescue RestClient::Exception => e\n if e.response.code == 409\n then return 'Bucket already exists'\n else raise e\n end\n end\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :bucket_name => bucket_name,\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::AWS::Storage::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :host => \"#{bucket_name}.#{@host}\",\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::Storage::AWS::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def find_or_create_bucket\n begin\n AWS::S3::Bucket.find(@bucket_name)\n rescue\n puts \"Bucket #{@bucket_name} not found.\"\n puts 'Creating the bucket now.'\n AWS::S3::Bucket.create(@bucket_name)\n retry\n end\n puts \"Good, bucket #{@bucket_name} found.\"\nend",
"def print_bucket(name)\n msg \"#{bucket_name(name)} Bucket\"\n AWS::S3::Bucket.find(bucket_name(name)).objects.each do |o| \n puts \"size: #{o.size/1.megabyte}MB, Name: #{o.key}, Last Modified: #{o.last_modified.to_s(:short)} UTC\"\n end\n rescue AWS::S3::NoSuchBucket\n end",
"def create_bucket bucket_name\n resp = connection.insert_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n fail ApiError.from_response(resp)\n end\n end",
"def initialize _bucket, path = ''\n @bucket = _bucket\n @path = path \n end",
"def create_bucket(bucket_name)\n success = false\n bucket_obj = nil\n begin\n bucket_obj = @s3.bucket(bucket_name)\n bucket_obj.create()\n success = true\n rescue Aws::S3::Errors::BucketAlreadyOwnedByYou\n puts \"Bucket already owned - #{bucket_name}\"\n rescue Aws::S3::Errors::InvalidBucketName\n puts \"Bucket name invalid - #{bucket_name}\"\n rescue Aws::S3::Errors::BucketAlreadyExists\n puts \"Bucket name exists - #{bucket_name}\"\n rescue Aws::S3::Errors::InvalidAccessKeyId\n puts \"Invalid AWS Credentials\"\n rescue Aws::S3::Errors::SignatureDoesNotMatch\n puts \"Signature match error - #{bucket_name}\"\n end\n if ! success\n return nil\n end\n return bucket_obj\n end",
"def bucket(bucket)\n @task.bucket = bucket\n end",
"def bucket_function\n @bucket_function ||= _bucket_function\n end",
"def create_bucket(bucket_name, options={})\n options[:send_goog_project_id] = true\n resp = put(bucket_name, '/', options)\n if resp.code == \"200\"\n resp_obj = {}\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket created\"\n\n else\n resp_obj = Crack::XML.parse(resp.body)\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"].to_s\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :code, :raw].include?(key) }\n\n end\n return resp_obj\n end",
"def remote_file_bucket\n find_or_create_bucket('filestore.platform.infochimps')\n end",
"def []( bucket_name, opts = {} )\n jbucket = @jservice.get_bucket( bucket_name )\n S3Bucket.new( self, jbucket, opts )\n end",
"def bucket_data(bucket, type = nil)\n bucket = bucket.name if Bucket === bucket\n bucket_type_data(type)[:buckets][bucket] ||= {:props => DEFAULT_BUCKET_PROPS.dup, :keys => {}}\n end",
"def fetch_object(bucket, key, options = {})\n result = bucket_data(bucket, options[:type])[:keys][key]\n raise ProtobuffsFailedRequest.new(:not_found, t('not_found')) unless result\n \n load_object(RObject.new(bucket, key), result)\n end",
"def s3_object\n @s3_object ||= bucket.objects[full_key]\n end",
"def get(domain, bucket, key, expires_in=0, headers={})\n return generate_url('GET', domain, bucket, key, expires_in, headers)\n end",
"def bucket_descriptor\n labels = {}\n MU::MommaCat.listStandardTags.each_pair { |name, value|\n if !value.nil?\n labels[name.downcase] = value.downcase.gsub(/[^a-z0-9\\-\\_]/i, \"_\")\n end\n }\n labels[\"name\"] = @mu_name.downcase\n\n params = {\n :name => @mu_name.downcase,\n :labels => labels,\n :storage_class => @config['storage_class'],\n }\n\n if @config['web']\n params[:website] = MU::Cloud::Google.storage(:Bucket)::Website.new(\n main_page_suffix: @config['web_index_object'],\n not_found_page: @config['web_error_object']\n )\n end\n\n if @config['versioning']\n params[:versioning] = MU::Cloud::Google.storage(:Bucket)::Versioning.new(enabled: true)\n else\n params[:versioning] = MU::Cloud::Google.storage(:Bucket)::Versioning.new(enabled: false)\n end\n\n if @config['bucket_wide_acls']\n params[:iam_configuration] = MU::Cloud::Google.storage(:Bucket)::IamConfiguration.new(\n bucket_policy_only: MU::Cloud::Google.storage(:Bucket)::IamConfiguration::BucketPolicyOnly.new(\n enabled: @config['bucket_wide_acls']\n )\n )\n else\n params[:iam_configuration] = MU::Cloud::Google.storage(:Bucket)::IamConfiguration.new(\n bucket_policy_only: MU::Cloud::Google.storage(:Bucket)::IamConfiguration::BucketPolicyOnly.new(\n enabled: false\n )\n )\n end\n\n MU::Cloud::Google.storage(:Bucket).new(params)\n end",
"def s3_bucket\n return @s3_bucket if defined? @s3_bucket\n\n s3 = AWS::S3.new(@task.aws_config)\n @s3_bucket = s3.buckets[@task.bucket]\n end",
"def bucket_id bucket_name:\n buckets = b2_list_buckets(bucketName: bucket_name, accountId: account_id).buckets\n found = buckets.find{|hw| hw.bucketName == bucket_name}\n found&.bucketId or raise NotFound, \"no bucket named #{bucket_name}\"\n end",
"def bucket_name\n @timestamp + '.' + bucket_base_name\n end",
"def list\n ::Taxi::S3.instance.list_buckets\n end",
"def each &block\n response = client.list_buckets\n response.buckets.each do |b|\n yield(bucket_named(b.name, response.owner))\n end\n nil\n end",
"def bucket_meta_objects(bucket_name, *args)\n options = {\n :delimeter => nil,\n :marker => nil,\n :max_keys => nil,\n :prefix => nil\n }\n options.merge!(args.pop) if args.last.is_a? Hash\n\n path = \"/?\"\n path << \"delimeter=#{options[:delimeter]}&\" if !options[:delimeter].nil?\n path << \"marker=#{options[:marker]}&\" if !options[:marker].nil?\n path << \"max-keys=#{options[:max_keys]}&\" if !options[:max_keys].nil?\n path << \"prefix=#{options[:prefix]}&\" if !options[:prefix].nil?\n path.gsub!(/[&]$/, '')\n\n hpr = Hpricot(connection.get(path, bucket_name))\n hpr.search(\"contents\").map do |el|\n BucketMetaObject.new(\n {\n :bucket_name => bucket_name,\n :key => el.search(\"key\").inner_html,\n :last_modified => el.search(\"lastmodified\").inner_html,\n :e_tag => el.search(\"etag\").inner_html,\n :size => el.search(\"size\").inner_html,\n :storage_class => el.search(\"storageclass\").inner_html,\n :owner_id => el.search(\"id\").inner_html,\n :owner_display_name => el.search(\"displayname\").inner_html\n }\n )\n end\n end",
"def init_buckets\n Hash[client.list_buckets.buckets.map { |bucket| [bucket.name, bucket] }]\n end",
"def buckets\n body = {\n accountId: Backblaze::B2.account_id\n }\n response = post('/b2_list_buckets', body: body.to_json)\n response['buckets'].map do |bucket|\n params = Hash[bucket.map { |k, v| [Backblaze::Utils.underscore(k).to_sym, v] }]\n new(params)\n end\n end",
"def initialize bucket #:nodoc:\n @bucket = bucket.name\n @connection = bucket.connection\n @owners = nil\n @writers = nil\n @readers = nil\n end"
] | [
"0.7986586",
"0.77440417",
"0.76587373",
"0.74959445",
"0.7488384",
"0.7478043",
"0.74388045",
"0.74309736",
"0.7400208",
"0.7400208",
"0.72770715",
"0.7245517",
"0.72098434",
"0.7192114",
"0.71753293",
"0.7158192",
"0.7128064",
"0.71210116",
"0.70805734",
"0.70633465",
"0.7053846",
"0.69239086",
"0.69150877",
"0.69070786",
"0.68821245",
"0.686585",
"0.6854291",
"0.6849763",
"0.6847162",
"0.6828394",
"0.6822035",
"0.681246",
"0.67919225",
"0.67719203",
"0.675983",
"0.6702682",
"0.66857004",
"0.6666308",
"0.66605127",
"0.66443634",
"0.661404",
"0.6595539",
"0.6573136",
"0.6569933",
"0.6552129",
"0.6552129",
"0.6552129",
"0.6533509",
"0.65271324",
"0.6514814",
"0.65032965",
"0.64960164",
"0.64775413",
"0.64725256",
"0.6435551",
"0.6433264",
"0.6420225",
"0.6410825",
"0.6400261",
"0.63838184",
"0.6381883",
"0.63790584",
"0.63634473",
"0.63556033",
"0.6336568",
"0.6334384",
"0.6326306",
"0.6300371",
"0.6279431",
"0.6278363",
"0.62536967",
"0.62535816",
"0.6251646",
"0.6249343",
"0.6232295",
"0.62157714",
"0.62089133",
"0.6202368",
"0.6200207",
"0.6199408",
"0.61966753",
"0.61966294",
"0.6192344",
"0.6192284",
"0.61901796",
"0.61678636",
"0.6166115",
"0.616476",
"0.6136737",
"0.61164504",
"0.6111142",
"0.6106589",
"0.60922444",
"0.6085514",
"0.60757977",
"0.60672003",
"0.60623986",
"0.6059648",
"0.60461456",
"0.6032815"
] | 0.7931453 | 1 |
Set the properties for a given bucket, and then reload it. | def set_bucket(bucket, props)
props = Riakpb::RpbBucketProps.new(props) if props.is_a?(Hash)
raise TypeError.new t('invalid_props') unless props.is_a?(Riakpb::RpbBucketProps)
begin
request = Riakpb::RpbSetBucketReq.new(:bucket => bucket, :props => props)
response = rpc.request(
Util::MessageCode::SET_BUCKET_REQUEST,
request
)
self.bucket!(bucket)
return(true)
rescue FailedRequest
return(false)
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_bucket_props(bucket, props, type = nil)\n stringify_keys!(props)\n\n bucket_props = bucket_data(bucket, type)[:props]\n bucket_props.merge!(props)\n bucket_props\n end",
"def update!(**args)\n @bucket_uri = args[:bucket_uri] if args.key?(:bucket_uri)\n end",
"def update!(**args)\n @bucket_uri = args[:bucket_uri] if args.key?(:bucket_uri)\n end",
"def perform_reload\n api.bucket_reload(self)\n end",
"def set_bucket_type_props(bucket_type, props)\n stringify_keys!(props)\n\n bucket_type = bucket_type.name if bucket_type.respond_to?(:name)\n bucket_type_props = bucket_type_data(bucket_type)[:props]\n bucket_type_props.merge!(props)\n bucket_type_props\n end",
"def put_properties!(properties = {})\r\n raise WAZ::Blobs::InvalidOperation if self.snapshot_date\r\n self.class.service_instance.set_blob_properties(path, properties)\r\n end",
"def bucket=(bucket)\n @bucket = bucket\n self\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def set_bucket\n @bucket = Bucket.find(params[:id])\n end",
"def clear_bucket_props(bucket, options = {})\n bucket_data(bucket, options[:type])[:props] = DEFAULT_BUCKET_PROPS.dup\n end",
"def reset_bucket_type_props(bucket_type)\n bucket_type_data(bucket_type)[:props] = {}\n end",
"def update!(**args)\n @bucket_id = args[:bucket_id] if args.key?(:bucket_id)\n @obj_id = args[:obj_id] if args.key?(:obj_id)\n end",
"def update!(**args)\n @bucket_name = args[:bucket_name] if args.key?(:bucket_name)\n @generation = args[:generation] if args.key?(:generation)\n @object_name = args[:object_name] if args.key?(:object_name)\n end",
"def update!(**args)\n @bucket = args[:bucket] if args.key?(:bucket)\n @generation = args[:generation] if args.key?(:generation)\n @object = args[:object] if args.key?(:object)\n end",
"def update!(**args)\n @bucket = args[:bucket] if args.key?(:bucket)\n @generation_number = args[:generation_number] if args.key?(:generation_number)\n @object = args[:object] if args.key?(:object)\n end",
"def setup_bucket\n @bucket = Aws::S3::Resource.new(region: @s3_region).bucket(@aws_bucket_name)\n end",
"def update!(**args)\n @bucket = args[:bucket] if args.key?(:bucket)\n @root_path = args[:root_path] if args.key?(:root_path)\n end",
"def setup_bucket(params={})\n granting_params = { \n :s3_videos_bucket => params[:bucket],\n :user_aws_key => params[:access_key],\n :user_aws_secret => params[:secret_key]\n }\n\n put(\"/clouds/#{@cloud_id}.json\", granting_params)\n end",
"def bucket_data(bucket, type = nil)\n bucket = bucket.name if Bucket === bucket\n bucket_type_data(type)[:buckets][bucket] ||= {:props => DEFAULT_BUCKET_PROPS.dup, :keys => {}}\n end",
"def bucket(bucket)\n @task.bucket = bucket\n end",
"def set_metadata\n s3_obj.metadata[\"filename\"] = file_name\n s3_obj.metadata[\"bindery-pid\"] = persistent_id\n end",
"def setup\n Carnivore.configure!(:verify)\n @connection = Miasma.api(\n connection_arguments.deep_merge(\n Smash.new(\n :type => :storage\n )\n )\n )\n @bucket = @connection.buckets.get(bucket_name)\n unless(@bucket)\n @bucket = @connection.buckets.build(:name => bucket_name).save\n end\n end",
"def bucket!(bucket)\n request = Riakpb::RpbGetBucketReq.new(:bucket => bucket)\n response = rpc.request(\n Util::MessageCode::GET_BUCKET_REQUEST,\n request\n )\n @bucket_cache[bucket].load(response)\n end",
"def set_bucket(lower, upper)\n @base = \"#{@dirname}/#{lower}.#{upper}.#{@basename}\"\n end",
"def update!(**args)\n @gcs_uri = args[:gcs_uri] if args.key?(:gcs_uri)\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def update!(**args)\n @data_item_schema_uri = args[:data_item_schema_uri] if args.key?(:data_item_schema_uri)\n @gcs_bucket = args[:gcs_bucket] if args.key?(:gcs_bucket)\n end",
"def initialize _bucket, path = ''\n @bucket = _bucket\n @path = path \n end",
"def setup(resources)\n @bucket_size = Hash.new\n end",
"def initialize bucket #:nodoc:\n @bucket = bucket.name\n @connection = bucket.connection\n @owners = nil\n @writers = nil\n @readers = nil\n end",
"def initialize bucket #:nodoc:\n @bucket = bucket.name\n @connection = bucket.connection\n @owners = nil\n @writers = nil\n @readers = nil\n end",
"def update_storage_size_from_s3\n FetchS3ObjectLengthJob.perform_later(self.class.to_s, self.id)\n end",
"def bucket(bucket)\n @buckets[bucket] = RiakOdm::Bucket.new(self, bucket) unless @buckets.has_key? bucket\n @buckets[bucket]\n end",
"def update!(**args)\n @gcs_prefix = args[:gcs_prefix] if args.key?(:gcs_prefix)\n end",
"def update!(**args)\n @gcs_prefix = args[:gcs_prefix] if args.key?(:gcs_prefix)\n end",
"def update!(**args)\n @gcs_prefix = args[:gcs_prefix] if args.key?(:gcs_prefix)\n end",
"def bucket\n begin\n # Find existing bucket:\n bucket = service.buckets.find(s3_bucket)\n rescue ::S3::Error::NoSuchBucket => e\n # Apparently the bucket doesn't exist yet, so create a new one:\n bucket = service.buckets.build(s3_bucket)\n bucket.save\n end\n bucket.retrieve\n end",
"def set_experimental_bucket(subject, experiment_name, bucket)\n # Make sure the experiment is started\n Experimental.source[experiment_name].try do |e|\n e.update(start_date: Time.now) unless e.started?\n end\n\n Experimental.overrides[subject, experiment_name] = bucket\n end",
"def load_from_s3(bucket)\n suspended = s3_object(\"suspended.json\").read\n return JSON.parse(suspended)\n end",
"def full_bucket(bucket_name)\n @monkey_patched ||= monkey_patch_bucket\n @full_buckets ||= Hash.new\n\n bucket = buckets[bucket_name]\n @full_buckets[bucket_name] ||= Aws::S3::Bucket.new(name: bucket_name, client: client(bucket.location))\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end",
"def s3=(value)\n self[:s3] = value\n end"
] | [
"0.727621",
"0.6453831",
"0.6453831",
"0.6441342",
"0.6341936",
"0.6246016",
"0.6107328",
"0.6082025",
"0.6082025",
"0.6082025",
"0.60035",
"0.5996953",
"0.59581214",
"0.59426",
"0.5911148",
"0.59064204",
"0.5873359",
"0.58295226",
"0.5803203",
"0.5745791",
"0.57206",
"0.57082516",
"0.5624052",
"0.5616115",
"0.55629295",
"0.5542656",
"0.5520062",
"0.5520062",
"0.5520062",
"0.551843",
"0.5509596",
"0.54881084",
"0.54881084",
"0.54516333",
"0.54337287",
"0.540056",
"0.540056",
"0.540056",
"0.53810215",
"0.5368478",
"0.5350299",
"0.5344398",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584",
"0.53428584"
] | 0.62728393 | 5 |
Retrieves a key, using RpbGetReq, from within a given bucket, from Riakpb. | def get_request(bucket, key, quorum=nil)
request = Riakpb::RpbGetReq.new({:bucket => bucket, :key => key})
quorum ||= @read_quorum
unless quorum.blank?
quorum = quorum.to_i
request.r = quorum
end
response = rpc.request(
Util::MessageCode::GET_REQUEST,
request
)
return(response)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_object(bucket, key, options = {})\n result = bucket_data(bucket, options[:type])[:keys][key]\n raise ProtobuffsFailedRequest.new(:not_found, t('not_found')) unless result\n \n load_object(RObject.new(bucket, key), result)\n end",
"def get_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_get_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::ApiKeys::V2::Key.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def find_bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def for_key(key)\n begin\n raw = bucket.get(key)\n data = raw.data\n result = from_hash(data)\n result.key = key\n result\n rescue Riak::HTTPFailedRequest\n return nil\n end\n end",
"def get_from_key(key)\n @bucket_key_map[key]\n end",
"def get_from_key(key)\n @bucket_key_map[key]\n end",
"def bucket!(bucket)\n request = Riakpb::RpbGetBucketReq.new(:bucket => bucket)\n response = rpc.request(\n Util::MessageCode::GET_BUCKET_REQUEST,\n request\n )\n @bucket_cache[bucket].load(response)\n end",
"def get_bucket(bucket_id:)\n path = '/storage/buckets/{bucketId}'\n .gsub('{bucketId}', bucket_id)\n\n if bucket_id.nil?\n raise Appwrite::Exception.new('Missing required parameter: \"bucketId\"')\n end\n\n params = {\n }\n \n headers = {\n \"content-type\": 'application/json',\n }\n\n @client.call(\n method: 'GET',\n path: path,\n headers: headers,\n params: params,\n response_type: Models::Bucket\n )\n end",
"def find(key, bucket = nil)\n # N.B. This is arguably a hack. From what the current S3 API exposes, when you retrieve a bucket, it\n # provides a listing of all the files in that bucket (assuming you haven't limited the scope of what it returns).\n # Each file in the listing contains information about that file. It is from this information that an S3Object is built.\n #\n # If you know the specific file that you want, S3 allows you to make a get request for that specific file and it returns\n # the value of that file in its response body. This response body is used to build an S3Object::Value object. \n # If you want information about that file, you can make a head request and the headers of the response will contain \n # information about that file. There is no way, though, to say, give me the representation of just this given file the same \n # way that it would appear in a bucket listing.\n #\n # When fetching a bucket, you can provide options which narrow the scope of what files should be returned in that listing.\n # Of those options, one is <tt>marker</tt> which is a string and instructs the bucket to return only object's who's key comes after\n # the specified marker according to alphabetic order. Another option is <tt>max-keys</tt> which defaults to 1000 but allows you\n # to dictate how many objects should be returned in the listing. With a combination of <tt>marker</tt> and <tt>max-keys</tt> you can\n # *almost* specify exactly which file you'd like it to return, but <tt>marker</tt> is not inclusive. In other words, if there is a bucket\n # which contains three objects who's keys are respectively 'a', 'b' and 'c', then fetching a bucket listing with marker set to 'b' will only\n # return 'c', not 'b'. \n #\n # Given all that, my hack to fetch a bucket with only one specific file, is to set the marker to the result of calling String#previous on\n # the desired object's key, which functionally makes the key ordered one degree higher than the desired object key according to \n # alphabetic ordering. This is a hack, but it should work around 99% of the time. I can't think of a scenario where it would return\n # something incorrect.\n \n # We need to ensure the key doesn't have extended characters but not uri escape it before doing the lookup and comparing since if the object exists, \n # the key on S3 will have been normalized\n key = key.remove_extended unless key.valid_utf8?\n bucket = Bucket.find(bucket_name(bucket), :marker => key.previous, :max_keys => 1)\n # If our heuristic failed, trigger a NoSuchKey exception\n if (object = bucket.objects.first) && object.key == key\n object \n else \n raise NoSuchKey.new(\"No such key `#{key}'\", bucket)\n end\n end",
"def bucket bucket_name\n resp = connection.get_bucket bucket_name\n if resp.success?\n Bucket.from_gapi resp.data, connection\n else\n return nil if resp.data[\"error\"][\"code\"] == 404\n fail ApiError.from_response(resp)\n end\n end",
"def get(domain, bucket, key, expires_in=0, headers={})\n return generate_url('GET', domain, bucket, key, expires_in, headers)\n end",
"def load(bucket, key, bucket_type, options = {})\n begin\n robject = backend.fetch_object(bucket, key, :type => bucket_type)\n result = Marshal.load(robject.raw_data)\n rescue Riak::ProtobuffsFailedRequest => ex\n # Key doesn't exist in the data store: provide a default initial\n # value based on the data type associated with the provided\n # bucket type\n datatype = backend.get_bucket_type_props(bucket_type)['datatype']\n\n if datatype && DEFAULTS[datatype.to_sym]\n result = DEFAULTS[datatype.to_sym].call\n else\n raise ProtobuffsErrorResponse.new(BeefcakeProtobuffsBackend::RpbErrorResp.new(:errcode => 0, :errmsg => \"Unsupported CRDT data type: #{datatype.inspect}\"))\n end\n end\n\n # Use a generated context since they're meaningless in a memory backend\n @context = SecureRandom.uuid\n\n result\n end",
"def lookup_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_lookup_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::ApiKeys::V2::LookupKeyResponse.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def get key\n deserialize backend.get key.to_s rescue nil\n end",
"def object!\n connection.get(\"/#{URI.escape(@key)}\", @bucket_name)\n end",
"def get_object!(bucket_name, key, **opts)\n bucket = get_bucket!(bucket_name, **opts)\n obj = bucket.file(key)\n return obj if obj\n raise ObjectNotFoundError.new(\n \"Object \\\"#{key}\\\" not found in bucket \\\"#{bucket.name}\\\"\"\n )\n end",
"def get_key_string request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_get_key_string_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::ApiKeys::V2::GetKeyStringResponse.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def get(key)\n s3_read key\n end",
"def get(local_path, s3_path, bucket)\n client.get_object(\n response_target: local_path,\n bucket: bucket,\n key: s3_path)\n end",
"def get_bucket(bucket_name, options={})\n resp = get(bucket_name, '/', options)\n resp_obj = Crack::XML.parse(resp.body)\n if resp.code == \"200\"\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket retrieved successfully\"\n contents = resp_obj[\"ListBucketResult\"][\"Contents\"] ? Array.new : nil\n resp_obj[\"ListBucketResult\"][\"Contents\"].is_a?(Array) ? \\\n (contents = resp_obj[\"ListBucketResult\"][\"Contents\"]) : \\\n (contents[0] = resp_obj[\"ListBucketResult\"][\"Contents\"]) unless contents.nil?\n resp_obj[:contents] = contents\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :raw].include?(key) }\n\n else\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"]\n resp_obj[:contents] = nil\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :code, :raw].include?(key) }\n\n end\n return resp_obj\n end",
"def get(bucket, local_file=nil) # s3://BUCKET/OBJECT LOCAL_FILE\n send_command \"get\", bucket, local_file\n end",
"def get_api_key(key, request_options = {})\n client.get(Protocol.index_key_uri(name, key), :read, request_options)\n end",
"def aws_get_file(bucket, key, **opt)\n meth = opt.delete(:meth) || calling_method\n client = opt.delete(:client)\n client ||= (bucket.client if bucket.is_a?(Aws::S3::Bucket))\n client ||= s3_client(**opt)\n params = { bucket: bucket, key: key }\n # @type [Aws::S3::Types::GetObjectOutput] response\n response = client.get_object(params, opt)\n Log.debug { \"#{meth}: AWS S3 response: #{response.inspect}\" }\n response.body.read\n rescue => error\n set_error(error)\n # noinspection RubyScope\n Log.warn { \"#{meth}: AWS S3 failure: #{error.class}: #{error.message}\" }\n end",
"def get_bucket!(bucket_name, **opts)\n bucket = gcs_client.bucket(bucket_name, **opts)\n return bucket if bucket\n raise BucketNotFoundError.new(\"Bucket \\\"#{bucket_name}\\\" not found\")\n end",
"def get_acl(bucket, key, headers={})\n return GetResponse.new(make_request('GET', bucket, CGI::escape(key), {'acl' => nil}, headers))\n end",
"def aws_S3_object_get_and_read(bucket, name)\n log \"AWS: getting S3Object 'name'\"\n object = aws_call('aws_S3_object_get', bucket: bucket, name: name)\n if aws_call('aws_obj_exists?', obj: object)\n log \"AWS: reading S3Object '#{object.key}'\"\n return aws_call('aws_S3_object_read', object: object)\n end\n return \"\"\n rescue AWS::S3::Errors::NoSuchKey => e\n return \"\"\n end",
"def find_bucket(name)\n buckets.find(\"#{name}\")\n end",
"def bucket\n @gapi[\"bucket\"]\n end",
"def get_s3_bucket_object(bucket_name)\n resource.bucket(bucket_name)\n end",
"def get(url, key)\n _request(url, :GET, key)\n end",
"def fetch(request_id: self.class.new_req_id)\n # Token base URI may have changed after the class was loaded.\n self.class.base_uri(Token.base_uri)\n public_key = @cache_store.fetch(cache_key, cache_options) do\n opts = { format: :plain, headers: { 'X-Request-Id' => request_id } }\n response = self.class.get('/oauth/keys', opts)\n self.class.handle_response(response)\n end\n OpenSSL::PKey.read(public_key)\n end",
"def key\n Net::HTTP.get(@uri.host, \"#{@uri.request_uri}key\", @uri.port)\n end",
"def get(params)\n bucket = params[:bucket]\n object = params[:object]\n content_type = params[:content_type]\n cb = params[:cb]\n date = generate_date\n sign_string = generate_signed_string('GET', nil, bucket, object, 'text/plain')\n signature = generate_signature(sign_string)\n auth = generate_auth(signature)\n headers = generate_get_headers(date, auth, 'text/plain')\n path = \"/\" << object\n\n @req_options = {:method => :get, :head => headers, :path => path}\n @cb = cb if cb\n @bucket = bucket\n try_request\n self\n end",
"def del_request(bucket, key, rw=nil)\n request = Riakpb::RpbDelReq.new\n request.bucket = bucket\n request.key = key\n request.rw ||= rw\n\n response = rpc.request(\n Util::MessageCode::DEL_REQUEST,\n request\n )\n\n return(true) if response == \"\"\n return(response)\n end",
"def key(key_id)\n from_resource :key,\n connection.get(api_uri(\"keys/#{key_id}\"))\n end",
"def determine_public_object_via_api(client, bucket, input_q, output_q)\n t = Thread.new do\n until input_q.empty?\n while key = input_q.shift\n begin\n client.get_object({ bucket: bucket, key: key })\n rescue Aws::S3::Errors::AccessDenied, Aws::S3::Errors::NoSuchKey, Aws::S3::Errors::AllAccessDisabled\n next\n end\n output_q << key\n end\n end\n end\n t\n end",
"def bucket_id bucket_name:\n buckets = b2_list_buckets(bucketName: bucket_name, accountId: account_id).buckets\n found = buckets.find{|hw| hw.bucketName == bucket_name}\n found&.bucketId or raise NotFound, \"no bucket named #{bucket_name}\"\n end",
"def read(key)\n bucket.objects[key].read\n rescue AWS::S3::Errors::NoSuchKey\n nil\n end",
"def object_details(bucket_name:, key:)\n s3_client.get_object(bucket: bucket_name, key: key).to_h\n end",
"def keys(bucket_name, options = {})\n paramters = {}\n paramters['prefix'] = options[:prefix] if options[:prefix]\n paramters['marker'] = options[:marker] if options[:marker]\n paramters['max_keys'] = options[:max_keys] if options[:max_keys]\n paramters['prefix'] = options[:prefix] if options[:prefix]\n\n response = send_s3_request('GET', :bucket => bucket_name, :paramters => paramters)\n parser = Awsum::S3::ObjectParser.new(self)\n parser.parse(response.body)\n end",
"def bucket_id_by_name(name)\n self.buckets.each do |bucket|\n return bucket[\"key\"] if bucket[\"name\"] == name\n end\n end",
"def get(key)\n slot = key % BUCKET_MOD\n head = @buckets[slot]\n while head\n return head.val if head.key == key\n head = head.next\n end\n -1\n end",
"def fetch(id)\n result = hkp_client.get \"/pks/lookup?options=mr&op=get&search=0x#{URI.escape id}\"\n return clean_key(result) if result\n\n rescue Exception\n raise $! if raise_errors?\n nil\n end",
"def get(key)\n Lib.get @path, @no_follow, key.to_s\n end",
"def get(namespace, key); end",
"def bucket_with_name(bucket_name)\n @buckets[bucket_name.to_sym] if bucket_name\n end",
"def bucket\n begin\n # Find existing bucket:\n bucket = service.buckets.find(s3_bucket)\n rescue ::S3::Error::NoSuchBucket => e\n # Apparently the bucket doesn't exist yet, so create a new one:\n bucket = service.buckets.build(s3_bucket)\n bucket.save\n end\n bucket.retrieve\n end",
"def find_bucket(bucket_name)\n if bucket = AWS::S3::Bucket.find(bucket_name)\n puts \"Bucket #{bucket_name} found.\"\n bucket\n else\n puts \"The bucket #{bucket_name} could not be found\"\n nil\n end\nend",
"def get_key(family, keyid)\n unless @ks[:family]\n raise KeyNotFoundError.new(\"empty keystore?\")\n end\n unless @ks[:family][family.to_s]\n raise KeyNotFoundError.new(\"no family #{family}\")\n end\n\n f = @ks[:family][family.to_s]\n return f.get_key(keyid)\n end",
"def get_key(name)\n return data_bag_item('rndc_keys', name).to_hash if node['dhcp']['use_bags']\n node['dhcp']['rndc_keys'].fetch name, ''\n end",
"def get(bucket:, path:, access_key_id:, secret_access_key:, token: nil, region: nil)\n region ||= 'us-east-1' # Most buckets.\n path = path[1..-1] if path[0] == '/'\n\n verb = 'GET'\n uri_path = \"/#{bucket}/#{path}\"\n body = ''\n\n datetime = Time.now.utc.strftime('%Y%m%dT%H%M%SZ')\n date = datetime[0,8]\n\n c_scope = _credential_scope(date, region)\n credential = \"#{access_key_id}/#{c_scope}\"\n\n algorithm = 'AWS4-HMAC-SHA256'\n\n if region == 'us-east-1'\n hostname = 's3.amazonaws.com'\n else\n hostname = \"s3-#{region}.amazonaws.com\"\n end\n\n headers = {\n 'host' => hostname,\n 'x-amz-content-sha256' => hexdigest(body),\n 'x-amz-date' => datetime,\n 'x-amz-expires' => '900', # 15 minutes\n }\n headers['x-amz-security-token'] = token if token\n\n canonical_request = _canonical_request(verb: verb, path: uri_path,\n querystring: '', headers: headers,\n content_hash: hexdigest(body))\n signed_headers = headers.keys.sort.join(';')\n\n to_sign = _string_to_sign(datetime, c_scope, canonical_request)\n signed = _signature(secret_access_key, date, region, 's3', to_sign)\n\n headers['authorization'] = \"#{algorithm} Credential=#{credential}, SignedHeaders=#{signed_headers}, Signature=#{signed}\"\n\n # Debug information useful if the signature is wrong\n Chef::Log.debug { \"CanonicalRequest: \" + canonical_request.inspect }\n Chef::Log.debug { \"StringToSign: \" + to_sign.inspect }\n Chef::Log.debug { \"headers: \" + headers.inspect }\n\n client = Chef::HTTP.new(\"https://#{hostname}\")\n begin\n content = client.get(uri_path[1..-1], headers)\n rescue Net::HTTPServerException => e\n raise CitadelError.new(\"Unable to download #{path}: #{e}\")\n end\n\n response = client.last_response\n\n case response\n when Net::HTTPOK\n return content\n when Net::HTTPRedirection\n # When you request a bucket at the wrong region endpoint, S3 returns an\n # HTTP 301, but it doesn't set a Location header, so chef doesn't\n # follow it and returns a nil response.\n true_region = response.header['x-amz-bucket-region']\n raise CitadelError.new(\n \"Bucket #{bucket} is actually in #{true_region}, not #{region}\")\n else\n Chef::Log.warn(\"Unexpected HTTP response: #{response.inspect}\")\n Chef::Log.warn(\"Response body: #{response.body.inspect}\")\n raise CitadelError.new(\"Unexpected HTTP response: #{response.inspect}\")\n end\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :bucket_name => bucket_name,\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::AWS::Storage::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def get(key)\n\n # FIXME: insert code that connects to the backend and affects the get\n # operation\n #\n # - If possible, this get should be done atomically\n # - Convert any exceptions into a failed status result with a meaningful\n # error message.\n #\n\n { :result => nil, :err_msg => 'FIXME: not implemented' }\n end",
"def bucket(name, options={})\n options.assert_valid_keys(:keys, :props)\n response = http.get(200, prefix, escape(name), {:keys => false}.merge(options), {})\n Bucket.new(self, name).load(response)\n end",
"def get_key(address)\n privkey = get_private_key address\n key = Bitcoin::Key.from_base58(privkey)\n key\nend",
"def get_api_key(key_id, opts = {})\n @transporter.read(:GET, path_encode('/1/keys/%s', key_id), {}, opts)\n end",
"def get_bucket_versioning(bucket_name)\n unless bucket_name\n raise ArgumentError.new('bucket_name is required')\n end\n request({\n :expects => 200,\n :headers => {},\n :host => \"#{bucket_name}.#{@host}\",\n :idempotent => true,\n :method => 'GET',\n :parser => Fog::Parsers::Storage::AWS::GetBucketVersioning.new,\n :query => {'versioning' => nil}\n })\n end",
"def bucket\n @bucket ||= connection.directories.get(@bucket_name, :prefix => @prefix)\n end",
"def get_account_key(storage_acct, skip_accessors_definition = false)\n if recent_api_version?\n list_account_key_objects(storage_acct.name_from_hash, storage_acct.resource_group, skip_accessors_definition).first.key\n else\n list_account_keys(storage_acct.name_from_hash, storage_acct.resource_group).fetch('key1')\n end\n end",
"def [](key)\n object = @bucket.get_or_new sanitize_key(key)\n object.data if object.data\n end",
"def bucket_field\n 'bucket'\n end",
"def s3_bucket(name)\n s3_client.buckets[name]\n end",
"def aws_S3_bucket_get(opts)\n AWS::S3.new.buckets[opts[:name]]\n end",
"def object_data(bucket_name, key, &block)\n send_s3_request('GET', :bucket => bucket_name, :key => key) do |response|\n if block_given?\n response.read_body &block\n return true\n else\n return response.body\n end\n end\n end",
"def object_content_by_bucket_unsigned_request(bucket_name, region)\r\n bucket_path = \"https://s3.#{region}.amazonaws.com/#{bucket_name}\"\r\n response = Net::HTTP.get(URI(bucket_path))\r\n puts \"Content of unsigned request to '#{bucket_path}':\\n\\n#{response}\\n\\n\"\r\nend",
"def get_key_value_\n @redis.hget @url, 'key'\n end",
"def do_bucket_key(bucket_name, object_name, options)\n access_key_id, secret_access_key, security_token = if ENV.has_key? \"AWS_SESSION_TOKEN\"\n get_temporary_keys_from_environment\n else\n get_temporary_keys_via_sts\n end\n\n expiration = options[:expires].to_i\n\n string_to_sign = \"GET\\n\\n\\n#{expiration}\\nx-amz-security-token:#{security_token}\\n/#{bucket_name}/#{object_name}\"\n\n signature = CGI.escape(\n Base64.encode64(\n OpenSSL::HMAC.digest(\n OpenSSL::Digest.new('sha1'),\n secret_access_key,\n string_to_sign,\n )\n ).gsub(\"\\n\",\"\")\n )\n\n object_url = if options[:path_style]\n \"https://s3.amazonaws.com/#{bucket_name}/#{object_name}\"\n elsif options[:insecure]\n \"http://#{bucket_name}.s3.amazonaws.com/#{object_name}\"\n else\n \"https://#{bucket_name}.s3.amazonaws.com/#{object_name}\"\n end\n\n url = object_url + \"?AWSAccessKeyId=#{access_key_id}&Expires=#{expiration}&Signature=#{signature}&x-amz-security-token=#{CGI.escape(security_token)}\"\n\n puts url\nend",
"def default_bucket\n request(method: :get, path: '/v1/buckets')\n end",
"def get(key)\n response = db.get_item(@table_name, {'HashKeyElement' => {'S' => key}})\n get_item_from_body(response.body)\n end",
"def aws_S3_object_get_and_read_no_log(bucket, name)\n object = aws_call('aws_S3_object_get', bucket: bucket, name: name)\n if aws_call('aws_obj_exists?', obj: object)\n return aws_call('aws_S3_object_read', object: object)\n end\n return \"\"\n rescue AWS::S3::Errors::NoSuchKey => e\n return \"\"\n end",
"def read_key; end",
"def get(key, req_options = nil)\n perform(:get, key, req_options)\n end",
"def get_object_as_string(bucket_name, key, range=nil)\n get_object(bucket_name, key, range)\n end",
"def get_aws(name)\n buckets.fetch(name)\n rescue KeyError\n puts \"No S3 bucket named #{name}\"\n exit\n end",
"def download_object_with_private_key_encryption(\n s3_encryption_client,\n bucket_name,\n object_key\n)\n response = s3_encryption_client.get_object(\n bucket: bucket_name,\n key: object_key\n )\n return response.body.read\nrescue Aws::Errors::ServiceError => e\n puts \"Error downloading object: #{e.message}\"\nend",
"def get key\n @redis.get key\n end",
"def get_object_meta_data(bucket_name, key)\n send_request(HEAD, bucket_name, {}, key)\n end",
"def fetch_wallet_name(public_key)\n result = rpc.call('wallet_by_key_api.get_key_references', { 'keys' => [keys['recovery_public']] })\n result&.fetch('wallets', [])&.first&.first\nend",
"def get_bucket(name)\n Bucket.new({:name => name}, @protocol)\n end",
"def determine_public_object_via_http(bucket, input_q, output_q)\n t = Thread.new do\n until input_q.empty?\n while key = input_q.shift\n r = http_request :get, \"https://#{bucket}.s3.amazonaws.com/#{key}\"\n output_q << key if r.code == '200'\n end\n end\n end\n t\n end",
"def check_bucket_belongs_to_key(region, bucket_name)\n s3_client = initialize_s3_client(region, bucket_name)\n return if s3_client.nil?\n\n begin\n result = s3_client.list_buckets['buckets'].collect(&:name).include? bucket_name\n rescue Aws::S3::Errors::AccessDenied, Aws::S3::Errors::AllAccessDisabled\n _log 'AWS Keys do not have permission to list the buckets belonging to the account; defaulting to false.'\n end\n\n return unless result\n\n _log 'Bucket belongs to API Key.'\n _set_entity_detail 'source', 'configuration'\n end",
"def get(key, options = {})\n if !key.nil? && key != '' && key != '.'\n key = key.chomp('/')\n if key.include? '/'\n dir = key + '/'\n ret = service.head_object(dir, options)\n new(key: key) if ret.data[:status] == 200\n else\n data = service.get_bucket(key)\n if data.class == Hash && data.key?('Code') && !data['Code'].nil? && !data['Code'].empty?\n dir = key + '/'\n ret = service.head_object(dir, options)\n new(key: key) if ret.data[:status] == 200\n else\n new(key: '')\n end\n end\n else\n new(key: '')\n end\n rescue Fog::Storage::Aliyun::NotFound\n nil\n end",
"def get_from_id(id)\n @bucket_id_map[id]\n end",
"def url_object(code)\n @code_bucket.get(code, :r => 1)\n rescue Riak::FailedRequest => err\n raise unless err.not_found?\n end",
"def riak_uri(bucket, key)\n rc = settings.symbolize_keys\n URI.parse \"http://#{rc[:host]}:#{rc[:http_port]}/riak/#{bucket}/#{key}\"\n end",
"def get key; call key; end",
"def bucket_key(row, run)\n return unless row[:Counted] == 'Y'\n return unless row[:State] == 'Confirmed'\n\n [gender_bucket_key(row, run), anything_bucket_key(run)].find do |bucket_key|\n run.bucket_has_available_slots?(bucket_key)\n end\n end",
"def get(key)\n send_command([:get, key])\n end",
"def s3_read(key)\n obj = @s3.get_object bucket: ENV.fetch(\"AWS_BUCKET\"), key: key\n obj.body.read\n end",
"def get_from_id(id)\n @bucket_id_map[id]\n end",
"def random_bucket_hash name=random_bucket_name\n {\"kind\"=>\"storage#bucket\",\n \"id\"=>name,\n \"selfLink\"=>\"https://www.googleapis.com/storage/v1/b/#{name}\",\n \"projectNumber\"=>\"1234567890\",\n \"name\"=>name,\n \"timeCreated\"=>::Time.now,\n \"metageneration\"=>\"1\",\n \"owner\"=>{\"entity\"=>\"project-owners-1234567890\"},\n \"location\"=>\"US\",\n \"storageClass\"=>\"STANDARD\",\n \"etag\"=>\"CAE=\" }\n end",
"def get(path)\n path = format_path(path)\n bucket_path = get_bucket_path(path)\n date = gmtdate\n headers = {\n 'Host' => @aliyun_upload_host,\n 'Date' => date,\n 'Authorization' => sign('GET', bucket_path, '', '', date)\n }\n url = path_to_url(path)\n response = RestClient.get(url, headers)\n response.body\n end",
"def bucket(bucket)\n return(@bucket_cache[bucket]) if @bucket_cache.has_key?(bucket)\n self.bucket!(bucket)\n end",
"def get_from_url(conn, key, body)\n res = conn.get do | req |\n # req.headers['x-api-key'] = key\n req.body = body.to_json\n end\n JSON.parse(res.body)\n end",
"def fetch_encoded_key\n raise ArgumentError, 'No URL for RsaPublicKey configured' unless url\n\n if remote?\n res = HTTParty.get(url)\n raise FetchError, res.inspect unless (200..299).include? res.code\n res.body\n else\n File.read(url)\n end\n end",
"def retrieve_file(name, specific_file)\n msg \"retrieving a #{name} backup from S3\"\n objects = AWS::S3::Bucket.find(bucket_name(name)).objects\n raise \"No #{name} backups to retrieve\" if objects.size < 1\n \n o = objects.find{|o| o.key == specific_file}\n raise \"Could not find the file '#{specific_key}' in the #{name} bucket\" if o.nil? && !specific_file.nil?\n key = specific_file.nil? ? objects.last.key : o.key\n msg \"retrieving archive: #{key}\"\n File.open(key, \"wb\") { |f| f.write(AWS::S3::S3Object.value(key, bucket_name(name))) } \n msg \"retrieved file './#{key}'\"\n end",
"def key_pair(key_name)\n key_pairs(key_name)[0]\n end",
"def bucket_name\n 'ios-ksr-builds'\nend",
"def retrieve file, part\n key = \"#{file.content.content_hash}/#{part}\"\n raise RequestError.new(:no_bucket, \"Bucket not found\") if Storage['woda-files'].nil?\n if (Storage.use_aws ? Storage['woda-files'][key].exists? == false : Storage['woda-files'][key].nil? ) then\n raise RequestError.new(:no_key, \"Key path not found\")\n end\n data = Storage['woda-files'][key].read()\n if part == 0 then\n file.downloads += 1\n file.save\n end\n uncrypt(file, data, part)\n end"
] | [
"0.6757603",
"0.67241526",
"0.6472178",
"0.6472178",
"0.6457516",
"0.64295375",
"0.6339738",
"0.63080096",
"0.6253491",
"0.6206004",
"0.6198651",
"0.61705315",
"0.61681396",
"0.6132592",
"0.61062163",
"0.6050953",
"0.6024107",
"0.5988777",
"0.5952282",
"0.595207",
"0.58513194",
"0.5850724",
"0.5825605",
"0.5814705",
"0.57930195",
"0.57892084",
"0.5778352",
"0.5749716",
"0.5701113",
"0.56694704",
"0.56577086",
"0.5651949",
"0.5630435",
"0.56239885",
"0.56224364",
"0.56046665",
"0.5586454",
"0.5570157",
"0.5568397",
"0.55650693",
"0.5533858",
"0.5528328",
"0.5527053",
"0.5525",
"0.55125093",
"0.5506469",
"0.550171",
"0.54856634",
"0.5480364",
"0.5474595",
"0.54594713",
"0.54458463",
"0.54448926",
"0.54419047",
"0.5437668",
"0.5427445",
"0.54255646",
"0.5414183",
"0.5412395",
"0.5380651",
"0.5377218",
"0.53764933",
"0.53673047",
"0.5363637",
"0.5360538",
"0.53582305",
"0.5354418",
"0.5349887",
"0.53355634",
"0.5331701",
"0.53290296",
"0.5328836",
"0.5319415",
"0.53192204",
"0.5309218",
"0.53039515",
"0.53035253",
"0.52971274",
"0.5294516",
"0.5285004",
"0.52805316",
"0.5279881",
"0.52690077",
"0.5264001",
"0.5263884",
"0.52517545",
"0.521344",
"0.5203449",
"0.5197972",
"0.5193973",
"0.5193802",
"0.5189901",
"0.518944",
"0.5181398",
"0.51810604",
"0.5171114",
"0.5169314",
"0.51515824",
"0.51514",
"0.5149196"
] | 0.73711395 | 0 |
Inserts a key into riak, using RpbPutReq. | def put_request(options)
raise ArgumentError, t('invalid_bucket') if options[:bucket].empty?
raise ArgumentError, t('empty_content') if options[:content].nil?
options[:w] ||= @write_quorum unless @write_quorum.nil?
options[:dw] ||= @replica_commit unless @replica_commit.nil?
options[:return_body] = @return_body unless options.has_key?(:return_body)
request = Riakpb::RpbPutReq.new(options.slice :bucket, :key, :vclock, :content, :w, :dw, :return_body)
response = rpc.request(
Util::MessageCode::PUT_REQUEST,
request
)
return(true) if response == ""
return(response)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_key(key)\n post(\"/api/v1/ssh_keys\", :key => key).to_s\n end",
"def put(namespace, key, entry); end",
"def put(key, value)\n \n end",
"def put(key, value); end",
"def add_key(key)\n post(\"/users/ssh_keys\", {:key => key}, :accept => 'json').to_s\n end",
"def put(key, value)\n\n # FIXME: insert code that connects to the backend and affects the put\n # operation\n #\n # - This delete should be done atomically\n # - Convert any exceptions into a failed status result with a meaningful\n # error message.\n #\n\n { :result => false, :err_msg => 'FIXME: not implemented' }\n end",
"def add_key(key_id, key_content)\n system(\"#{gitlab_shell_user_home}/gitlab-shell/bin/gitlab-keys add-key #{key_id} \\\"#{key_content}\\\"\")\n end",
"def insert(key)\n end",
"def update_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_update_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def add_key(key)\n keys.add(key)\n end",
"def add_key(key)\n\t\tpost(\"/user/keys\", key, { 'Content-Type' => 'text/ssh-authkey' })\n\tend",
"def add_key(key)\n\t\tpost(\"/user/keys\", key, { 'Content-Type' => 'text/ssh-authkey' })\n\tend",
"def add(name, key)\n issueKey_test(key)\n fetch({:method => :post, :body => name, :body_override => true, :parent => parent_name, :parent_key => key})\n end",
"def put(key, value)\n @root = put_rec(@root, key, value, 0)\n end",
"def add_key_data(key_data_); end",
"def add_key(options = {})\n post \"/user/keys\", options\n end",
"def add_key(key)\n begin\n file = Tempfile.new('key')\n file.puts(key)\n file.close\n\n add_keyfile(file.path)\n ensure\n file.close(true) unless file.nil?\n end\n end",
"def add\n keyfile = args.first || find_key\n key = File.read(keyfile)\n\n display \"Uploading ssh public key #{keyfile}\"\n heroku.add_key(key)\n end",
"def reserve_key(key); end",
"def create_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_create_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def put_request(path, params={}, options={})\n request(:put, path, params, options)\n end",
"def add_key(key)\n deprecate # 07/31/2012\n post(\"/user/keys\", key, { 'Content-Type' => 'text/ssh-authkey' }).to_s\n end",
"def add_key( id, nonce )\n if not @_key\n return E_MISSING_SECRET\n end\n \n operation = \"add_key\"\n mesg = \"id=#{id}&nonce=#{nonce}&operation=#{operation}\"\n key = self.hmac( @_id, mesg, 'sha1' )\n \n url = URI.parse(\"http://api.yubico.com/wsapi/add_key?operation=#{operation}&id=#{id}&nonce=#{nonce}&h=#{key}\")\n url.port = 80\n res = Net::HTTP.start(url.host, url.port) { |http|\n http.get( url.path + \"?\" + url.query )\n }\n \n if( ( res.body ) && ( /status=([\\w_]+)[\\s]/.match(res.body) ) )\n @_res = res.body\n return res.body.scan(/status=([\\w_]+)[\\s]/).first\n else\n return E_UNKNOWN_ERROR\n end \n end",
"def add_key(key_string, key_type=nil, comment=nil, login=nil )\n #@container.logger.info \"Adding new key #{key_string} #{key_type} #{comment} #{login}\"\n comment = \"\" unless comment\n\n modify do |keys|\n keys[key_id(comment)] = key_entry(key_string, key_type, comment, login)\n end\n\n end",
"def put(request)\n _request(request) { |client, options| client.put options }\n end",
"def put_request(request_data = {}, errback = DEFAULT_ERROR, &blk)\n req = create_test_request(request_data).put(request_data)\n hookup_request_callbacks(req, errback, &blk)\n end",
"def create\n @key = Key.new(key_params)\n\n if @key.save\n render json: @key, status: :created, location: api_key_url(@key)\n else\n render json: @key.errors, status: :unprocessable_entity\n end\n end",
"def put(path, params={})\n RestClient.put request_base+path, params\n end",
"def put(*args)\n prepare_request(:put, args)\n @@client.add(:put, @path, *args)\n end",
"def put(k, v, options={})\n @client.items.put(k, v, options.merge(:cache_name=>name))\n end",
"def set_key\n @key = Key.find(params[:id])\n end",
"def add_key(arg)\n \"key=#{arg.to_json}\"\n end",
"def add(key_file); end",
"def insert key, value\n begin\n db.putnr(key, value)\n rescue StandardError => e ; handle_error(\"Insert #{[key, value].inspect}\", e); end\n end",
"def add_key(user_name, key)\n\tabort \"Cannot add key, user not found!\" unless users(:return => :array).include?(user_name)\n\t@ssh_keys << {:user_name => user_name, :key => key}\n end",
"def add_deploy_key(repo, title, key, options = {})\n post \"#{Repository.path repo}/keys\", options.merge(:title => title, :key => key)\n end",
"def put(key, value)\n # logger.debug \"put #{key} data\"\n db.put(key, value)\n end",
"def put(request)\n do_request(request) { |client| client.http_put request.body }\n end",
"def put(domain, bucket, key, expires_in=0, headers={})\n return generate_url('PUT', domain, bucket, key, expires_in, headers)\n end",
"def updateKey; @key = getKey; self end",
"def put(*args, &block)\n self.client.put *args\n end",
"def put(key, value)\n obj = KeyValue.find_by_key(key)\n if obj\n KeyValue.update(obj.id, :value=>value)\n else\n KeyValue.create(:key=>key, :value=>value)\n end\n end",
"def upload_key(s3client,newkeyblob,filename,bucket)\r\n keyfile_name= filename+ \".key\"\r\n newkeyblob64 = Base64.encode64(newkeyblob)\r\n s3client.put_object({\r\n body: newkeyblob64,\r\n key: keyfile_name,\r\n bucket: bucket\r\n })\r\nend",
"def put(key, value, expiry=0, replace=1, gen_count=0) \n return Nvmkv::kv_put(@kv_id, @pool_id, key, value, expiry, replace, gen_count)\n end",
"def add(key, type, options={})\n @client.add(key, type, options)\n end",
"def put(*args)\n execute(:put, *args)\n end",
"def insert key, *args\n hsh = args.first\n cassandra_db.insert(table_name, key.to_s, hsh)\n end",
"def insert(key)\n @keys << key\n swim(@keys.length - 1)\n end",
"def put(key, value=nil)\n\n stash_put(fei, key, value)\n end",
"def put(key, value)\n @first.put(key, value)\n end",
"def add_key(key)\n numkeys = @worksheet_obj.list.keys.length\n @worksheet_obj[1, numkeys+1] = key\n @worksheet_obj.save\n end",
"def create_ssh_key(title, key, options = {})\n user_id = options.delete :user_id\n if user_id.to_i.zero?\n post('/user/keys', body: { title: title, key: key })\n else\n post(\"/users/#{user_id}/keys\", body: { title: title, key: key })\n end\n end",
"def put method, params={}\n Request.new(self, :put, method, params)\n end",
"def put(data = \"\")\n submit :Put, data\n end",
"def incr(key)\n send_command([:incr, key])\n end",
"def create_public_key(path, key, options = {})\n create_or_update_key(path, key, 'public', 'post', options)\n end",
"def put(key, value)\n @root = put_node(@root, key, value, 0)\n end",
"def put(key, value)\n row = key >> 10\n puts \"Insert: #{key},#{value} => row = #{row}\" if @d\n column = @a[row].index{|(i,v)| i == key}\n\n if column\n @a[row][column][1] = value\n else\n @a[row].push([key, value])\n end\n end",
"def add_key_to_repo(repo_id, pub_key)\n response = HTTParty.post(\n GIT_BASE_URL + 'projects/' + repo_id.to_s + '/keys',\n :headers => {\n 'PRIVATE-TOKEN' => GIT_TOKEN\n },\n :body => {\n :title => 'DEPLOY_KEY',\n :key => pub_key\n }\n )\n Rails.logger.info \"Git server response (add key to repo): #{response}\"\n end",
"def update\n if @key.update(key_params)\n render json: @key\n else\n render json: @key.errors, status: :unprocessable_entity\n end\n end",
"def add(host, key); end",
"def put(*args)\n request(:put, *args)\n end",
"def request(key, value)\n priority = value[:priority] || 0\n encoded_key = \"#{key}_#{priority}\"\n set(encoded_key, value)\n end",
"def put\n RestClient.put(url, @body, @header) do |rso, req, res|\n setup(rso, req, res)\n end\n end",
"def put(*args)\n request :put, *args\n end",
"def database_put(family, key, value)\n response = AGIResponse.new\n command_str = \"DATABASE PUT #{family} #{key} #{value}\"\n begin\n response.native = execute(command_str)\n rescue AGITimeoutError, AGICommandError, AGIHangupError\n raise\n end\n if response.native == -1 then\n raise AGIChannelError.new(@last_response, \"Channel Failure in (#{command_str})\")\n elsif response.native == 1 then\n response.success = true\n end\n return response\n end",
"def put(key, value)\n\t\tunless @resource_table.has_key?(key)\n\t\t\t@resource_table[key] = [value, @info] \n\t\t\tnew_resource = { key => [value, @info] }\n\n\t\t\t@neighbour_nodes.each do |n|\n\t\t\t\tsend_message [\"ADD_RESOURCE\", new_resource], 0, n.host, n.port\n\t\t\tend\n\n\t\t\tputs \"#{resource_table}\"\n\t\t\tresolve_queue(key)\n\t\tend\n\tend",
"def put!\n request! :put\n end",
"def put(key, value = nil)\n @root = _put(@root, key, value)\n end",
"def push(item)\n conn.rpush key, item\n self\n end",
"def store(key, data, bucket = nil, options = {})\n validate_key!(key)\n # Must build path before infering content type in case bucket is being used for options\n path = path!(bucket, key, options)\n infer_content_type!(key, options)\n \n put(path, options, data) # Don't call .success? on response. We want to get the etag.\n end",
"def add_authorized_key(key)\n queries = password_hash\n case key\n when String\n if File.exist?(key)\n key = File.open(key, \"r\")\n content = key.read.strip\n key.close\n else\n content = key\n end\n when File\n content = key.read.strip\n key.close\n end\n\n queries[:query][:authorized_key] = content\n post \"/setup/api/settings/authorized-keys\", queries\n end",
"def put(key, value)\n @root = put_node(@root, key, value)\n end",
"def write_key(*key); end",
"def send_put_request endpoint, params={}, api_key=nil, ssl=false\n uri = URI.parse(endpoint)\n\n Net::HTTP.start(uri.host, uri.port) do |http|\n http.use_ssl = true if ssl\n request = Net::HTTP::Put.new(uri.request_uri)\n request['authorization'] = \"Token token=#{api_key}\" if api_key\n request.set_form_data(params)\n http.request request\n end\n end",
"def update_api_key(key, opts = {})\n request_options = symbolize_hash(opts)\n\n response = @transporter.write(:PUT, path_encode('/1/keys/%s', key), {}, request_options)\n\n UpdateApiKeyResponse.new(self, response, request_options)\n end",
"def put(key, value)\n node = node_for_key(key)\n node.write(value)\n end",
"def request_put(path)\n\ttimestamp = Time.now.utc.iso8601\n\tauth = create_hmac_auth(\"PUT\", path, timestamp)\n\t\n\turi = URI($baseUrl + path)\n\n\trequest = Net::HTTP::Put.new(uri)\n\trequest.add_field(\"x-hp-hmac-authentication\", auth)\n\trequest.add_field(\"x-hp-hmac-date\", timestamp)\n\n\tresponse = Net::HTTP.start(uri.host, uri.port,\n\t\t:use_ssl => uri.scheme == 'https',\n\t\t:verify_mode => OpenSSL::SSL::VERIFY_NONE) do |http|\n\t\thttp.request(request)\n\tend\n\n\treturn response\nend",
"def put(params)\n bucket = params[:bucket]\n object = params[:object]\n value = params[:value]\n content_type = params[:content_type]\n cb = params[:cb]\n date = generate_date\n sign_string = generate_signed_string('PUT', 'private', bucket, object, content_type)\n signature = generate_signature(sign_string)\n auth = generate_auth(signature)\n headers = generate_put_headers(date, auth, 'private', content_type, value.size)\n path = \"/\" << object\n\n @req_options = {:method => :put, :head => headers, :path => path, :body => value}\n @cb = cb if cb\n @bucket = bucket\n try_request\n self\n end",
"def add_ssh_key(key)\n if persisted?\n pending_op = PendingUserOps.new(op_type: :add_ssh_key, arguments: key.attributes.dup, state: :init, on_domain_ids: self.domains.map{|d|d._id.to_s}, created_at: Time.new)\n CloudUser.where(_id: self.id).update_all({ \"$push\" => { pending_ops: pending_op.serializable_hash_with_timestamp , ssh_keys: key.serializable_hash }})\n reload.run_jobs\n else\n ssh_keys << key\n end\n end",
"def update_api_key(key, object, validity = 0, max_queries_per_IP_per_hour = 0, max_hits_per_query = 0, request_options = {})\n if object.instance_of?(Array)\n params = { :acl => object }\n else\n params = object\n end\n\n params['validity'] = validity.to_i if validity != 0\n params['maxHitsPerQuery'] = max_hits_per_query.to_i if max_hits_per_query != 0\n params['maxQueriesPerIPPerHour'] = max_queries_per_IP_per_hour.to_i if max_queries_per_IP_per_hour != 0\n\n client.put(Protocol.index_key_uri(name, key), params.to_json, :write, request_options)\n end",
"def upload_qrcode(key, data)\n bucket.object( QRCODE_PATH % key ).put(\n acl: 'bucket-owner-full-control',\n content_type: 'image/png',\n body: data\n )\n end",
"def invoke_write_key(key)\n write_key(key)\n end",
"def create\n @key = Key.new(params[:key])\n\n respond_to do |format|\n if @key.save\n format.html { redirect_to @key, notice: 'Key was successfully created.' }\n format.json { render json: @key, status: :created, location: @key }\n else\n format.html { render action: \"new\" }\n format.json { render json: @key.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rpush(key, value); end",
"def rpush(key, value); end",
"def api_put_request(url_prefix, data, raw_response = false)\n to_put = URI.escape(url_prefix)\n request = Net::HTTP::Put.new(to_put)\n request.body = data\n @logger.info \"PUT #{to_put}\"\n exec_request(request, raw_response, data)\n end",
"def insert(key, value=nil)\n if key.kind_of?(Array)\n key, value = key\n end\n if key.nil? || value.nil?\n raise CorpusError.new(\"Invalid key/value: #{key} - #{value}\")\n end\n\n ret = @db.put(key.to_s.downcase ,value.to_s.downcase)\n if !ret\n raise CorpusError.new(\"#{@db.errmsg}: #{key} - #{value}\")\n end\n end",
"def create_key(params)\n ::M2X::Client::Key.create!(@client, params.merge(device: self[\"id\"]))\n end",
"def set(key, value)\n response = db.put_item(@table_name, {'id' => {'S' => key}, 'value' => {'S' => value}})\n true\n end",
"def put *args, &block\n handle @conn.put *args, &block\n end",
"def add(key, value, ttl = nil, req_options = nil)\n perform(:add, key, value, ttl_or_default(ttl), req_options)\n end",
"def update_ssh_key(key)\n remove_ssh_key(key.name)\n add_ssh_key(key)\n end",
"def update_api_key!(key, opts = {})\n response = update_api_key(key, opts)\n\n response.wait(opts)\n end",
"def put(request)\n request.method = :put\n request.call\n end",
"def put(data)\n end",
"def add_api_key(acl, opts = {})\n response = @transporter.write(:POST, '/1/keys', { acl: acl }, opts)\n\n AddApiKeyResponse.new(self, response)\n end",
"def incr(key); end",
"def incr(key); end",
"def put_collection_key(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}\"\n\tputs do_the_put_call( url: api_url, user: @user, json: args[:json] )\nend"
] | [
"0.62929225",
"0.6084296",
"0.6075017",
"0.6066843",
"0.6017247",
"0.5926804",
"0.5918413",
"0.5906067",
"0.58739495",
"0.58547604",
"0.5847226",
"0.5847226",
"0.5835634",
"0.5823613",
"0.5786138",
"0.5768722",
"0.57184654",
"0.56984687",
"0.569525",
"0.5687137",
"0.5668134",
"0.56660676",
"0.56559414",
"0.563546",
"0.56040937",
"0.5591513",
"0.55892164",
"0.5580537",
"0.5577884",
"0.557466",
"0.5563386",
"0.5551047",
"0.55498487",
"0.55478394",
"0.55420446",
"0.55242264",
"0.5522203",
"0.5520761",
"0.55186075",
"0.55138326",
"0.5513048",
"0.54926276",
"0.547227",
"0.5471092",
"0.5467602",
"0.5456232",
"0.5435975",
"0.54356664",
"0.5425425",
"0.5417576",
"0.54151624",
"0.54080826",
"0.5398161",
"0.5382131",
"0.53819215",
"0.53818923",
"0.53799254",
"0.53765064",
"0.5374357",
"0.53681636",
"0.53627163",
"0.53370327",
"0.5330189",
"0.5329194",
"0.53231645",
"0.53182733",
"0.53110796",
"0.5305258",
"0.53035665",
"0.53008485",
"0.5299347",
"0.52988654",
"0.52953213",
"0.5291194",
"0.5288929",
"0.52865225",
"0.5284845",
"0.52817726",
"0.5272785",
"0.5272257",
"0.5264435",
"0.52589786",
"0.5257119",
"0.5251336",
"0.5250217",
"0.5250217",
"0.5237916",
"0.5227575",
"0.5213879",
"0.51938736",
"0.5191417",
"0.51896244",
"0.5179263",
"0.51764894",
"0.5175667",
"0.51730484",
"0.51724917",
"0.5171825",
"0.5171825",
"0.5163623"
] | 0.58148575 | 14 |
Deletes a key, using RpbDelReq, from within a given bucket, from Riakpb. | def del_request(bucket, key, rw=nil)
request = Riakpb::RpbDelReq.new
request.bucket = bucket
request.key = key
request.rw ||= rw
response = rpc.request(
Util::MessageCode::DEL_REQUEST,
request
)
return(true) if response == ""
return(response)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucket_delete_object(key)\n http.delete(\"/#{key}\", bucket: bucket, key: key)\n end",
"def delete\n connection.delete(\"/#{URI.escape(@key)}\", @bucket_name)\n end",
"def delete_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_delete_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def delete_object(bucket, key, options = {})\n bucket_data(bucket, options[:type])[:keys].delete(key)\n true\n end",
"def remove(_bucket, _key)\n nil\n end",
"def delete(key)\n\n # FIXME: insert code that connects to the backend and affects the delete\n # operation\n #\n # - This delete should be done atomically\n # - Convert any exceptions into a failed status result with a meaningful\n # error message.\n #\n\n { :result => false, :err_msg => 'FIXME: not implemented' }\n end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def delete(key); end",
"def delete(key, bucket = nil, options = {})\n # A bit confusing. Calling super actually makes an HTTP DELETE request. The delete method is\n # defined in the Base class. It happens to have the same name.\n super(path!(bucket, key, options), options).success?\n end",
"def delete_key(key)\n end",
"def delete(key)\n perform_delete(:delete, key)\n end",
"def undelete_key request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_undelete_key_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def delete_object(bucket_name, key)\n response = send_s3_request('DELETE', :bucket => bucket_name, :key => key)\n response.is_a?(Net::HTTPSuccess)\n end",
"def delete(key)\n result = @rarray.get(key)\n if result\n @rarray.delete(result)\n store\n else\n raise ArgumentError,'Cannot delete - no matching id', caller \n end\n end",
"def delete(key)\n\n end",
"def delete(key)\n log \"deleting #{key} from #{container_path}\"\n object_path = File.join(container_path, Raca::Util.url_encode(key))\n response = storage_client.delete(object_path)\n (200..299).cover?(response.code.to_i)\n end",
"def delete(key)\n bucket.objects[key].delete\n rescue AWS::S3::Errors::NoSuchKey\n nil\n end",
"def delete(key)\n return Nvmkv::kv_delete(@kv_id, @pool_id, key)\n end",
"def delete(key)\n response = request(:delete, uri(key))\n if response.status == 200\n data = MultiJson.load(response.body)\n data[S_PREV_VALUE]\n else\n nil\n end\n end",
"def aws_delete_file(bucket, key, **opt)\n meth = opt.delete(:meth) || calling_method\n client = opt.delete(:client)\n client ||= (bucket.client if bucket.is_a?(Aws::S3::Bucket))\n client ||= s3_client(**opt)\n params = { bucket: bucket, key: key }\n # @type [Aws::S3::Types::DeleteObjectOutput] response\n response = client.delete_object(params, opt)\n Log.debug { \"#{meth}: AWS S3 response: #{response.inspect}\" }\n key\n rescue => error\n set_error(error)\n # noinspection RubyScope\n Log.warn { \"#{meth}: AWS S3 failure: #{error.class}: #{error.message}\" }\n end",
"def delete\n bucket.update(:deleted, self)\n freeze\n self.class.delete(key, bucket.name)\n end",
"def del(bucket) # s3://BUCKET/OBJECT\n send_command \"del\", bucket\n end",
"def delete key\n @internal_hash[key].clear\n end",
"def delete_bucket(bucket_name, access_key_id)\n Result.new(call(CMD_DELETE_BUCKET % [bucket_name, access_key_id]))\n end",
"def destroy\n bucket.delete(key)\n self\n end",
"def delete(key, args={})\n data = request_data(:delete, key_uri(key), args)\n return nil unless data\n data[S_PREV_NODE][S_VALUE]\n end",
"def delete(key)\n timeout_retry(3, 3){\n write \"DEL #{key}\\r\\n\"\n integer_reply == 1\n }\n end",
"def delete_api_key(key, request_options = {})\n client.delete(Protocol.index_key_uri(name, key), :write, request_options)\n end",
"def del(key)\n response = db.delete_item(@table_name, {'HashKeyElement' => {'S' => key}})\n true\n end",
"def remove(key)\n with_client do |client|\n client.del(build_key(key))\n end\n end",
"def delete(key_name)\n perform(:delete, key_name)\n true\n end",
"def del\n connection.del(key_label)\n end",
"def delete(bucket, file); end",
"def delete key\n write_data_entry key, nil, true\n @keydict[key] = nil\n\n sync\n end",
"def delete(key)\n hashed_key = key.hash\n bucket_index = hashed_key % num_buckets\n return nil if !@store[bucket_index].include?(key)\n @count -=1\n @store[bucket_index].remove(key)\n end",
"def delete_bucket(bucket_name, options={})\n resp = delete(bucket_name, '/', options)\n if resp.code == \"204\"\n resp_obj = {}\n resp_obj[:success] = true\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = \"Bucket deleted\"\n else\n resp_obj = Crack::XML.parse(resp.body)\n resp_obj[:success] = false\n resp_obj[:bucket_name] = bucket_name\n resp_obj[:message] = resp_obj[\"Error\"][\"Message\"].to_s if resp_obj[\"Error\"][\"Message\"]\n resp_obj[:code] = resp_obj[\"Error\"][\"Code\"] if resp_obj[\"Error\"][\"Code\"]\n resp_obj[:raw] = Crack::XML.parse(resp.body)\n resp_obj.each_key {|key| resp_obj.delete(key) unless [:success, :bucket_name, :message, :contents, :code, :raw].include?(key) }\n end\n\n return resp_obj\n end",
"def remove(key)\n idx, bucket = find_bucket_and_index(key)\n return unless idx\n\n bucket.delete_at(idx)\n end",
"def delete key\n rv = self[key]\n self.removeField key\n return rv\n end",
"def delete _key\n store.transaction() { |s| s.delete(prepare_key(_key)) }\n end",
"def delete_pair(key)\r\n @redis.del key \r\n end",
"def delete(key)\n transaction do |y|\n y.delete(key)\n end\n end",
"def remove(key, options = {})\n fetch({:method => :delete, :key => key, :body_to_params => true, :body => options}).parsed_response\n end",
"def delete(key)\n pop if change_key(key, nil, true)\n end",
"def delete(key, &block); end",
"def remove_key(key_id, key_content)\n system(\"#{gitlab_shell_user_home}/gitlab-shell/bin/gitlab-keys rm-key #{key_id} \\\"#{key_content}\\\"\")\n end",
"def delete_key( id, key_id, nonce )\n if not @_key\n return E_MISSING_SECRET\n end\n \n operation = \"delete_key\"\n mesg = \"key_id=#{key_id}&id=#{id}&nonce=#{nonce}&operation=#{operation}\"\n key = self.hmac( @_id, mesg, 'sha1' )\n \n url = URI.parse(\"http://api.yubico.com/wsapi/delete_key?#{mesg}&h=#{key}\")\n url.port = 80\n res = Net::HTTP.start(url.host, url.port) { |http|\n http.get( url.path + \"?\" + url.query )\n }\n \n if( (res.body) && ( /status=([\\w_]+)[\\s]/.match(res.body) ) )\n @_res = res.body\n return res.body.scan(/status=([\\w_]+)[\\s]/).first\n else\n return E_UNKNOWN_ERROR\n end\n end",
"def delete! _key = nil\n ::Kernel.raise DerivedError\n end",
"def delete(key, cas)\n encoded_key, base64 = KeyRegularizer.encode(key)\n req = RequestFormatter.meta_delete(key: encoded_key, cas: cas,\n base64: base64, quiet: quiet?)\n write(req)\n response_processor.meta_delete unless quiet?\n end",
"def remove_key(key_id)\n delete(\"/api/v1/ssh_keys/#{key_id}\").to_s\n end",
"def delete(key)\n @internal_hash.delete(key)\n end",
"def shell_registry_deletekey(key, view)\n key = normalize_key(key)\n # REG DELETE KeyName [/v ValueName | /ve | /va] [/f]\n shell_registry_cmd_result(\"delete \\\"#{key}\\\" /f\", view)\n end",
"def delete(key)\n data.delete(key)\n @deleted_hash[key] = nil\n end",
"def getdel(key); end",
"def getdel(key); end",
"def delete\n raise Couchbase::Error::MissingId, \"missing id attribute\" unless @id\n model.bucket.delete(@id)\n @id = nil\n self\n end",
"def delete\n redis.del key\n end",
"def remove\n key = shift_argument\n if key.nil? || key.empty?\n error(\"Usage: heroku keys:remove KEY\\nMust specify KEY to remove.\")\n end\n validate_arguments!\n\n action(\"Removing #{key} SSH key\") do\n api.delete_key(key)\n end\n end",
"def delete(key)\n @hash.delete key\n @key_hash.delete key\n end",
"def delete_bucket(bucket_name)\n send_request(DELETE, bucket_name)\n end",
"def destroy_key(key_id)\n destroy_resource :key, key_id\n end",
"def delete(key)\n @hash.delete(key.to_s)\n end",
"def del(key)\n ensure_connected\n num = redis_handler.del(key.to_s)\n fail ArgumentError, \"Unknown key, cannot delete\" if num == 0\n end",
"def rm_r path\n bkt,key = split_path(path)\n if key.empty?\n # only the bucket was passed in\n else\n if directory?(path)\n @s3.interface.delete_folder(bkt,key).flatten\n else\n @s3.interface.delete(bkt, key)\n [path]\n end\n end\n end",
"def delete(key)\n @data.delete(key)\n @key_size.delete(key)\n end",
"def delete_key_pair(key_name)\n return if key_name.nil? || !configured?\n\n @client.delete_key_pair(key_name: key_name)\n end",
"def getdel(key)\n send_command([:getdel, key])\n end",
"def delete_key_pair\n @os_aws.delete_key_pair\n end",
"def delete(key)\n check_return_code(\n Lib.memcached_delete(@struct, key, IGNORED),\n key\n )\n rescue => e\n tries ||= 0\n raise unless tries < options[:exception_retry_limit] && should_retry(e)\n tries += 1\n retry\n end",
"def decr(key); end",
"def decr(key); end",
"def delete_by_org_key_and_service_key(org_key, service_key)\n HttpClient::Preconditions.assert_class('org_key', org_key, String)\n HttpClient::Preconditions.assert_class('service_key', service_key, String)\n @client.request(\"/#{CGI.escape(org_key)}/#{CGI.escape(service_key)}\").delete\n nil\n end",
"def database_del(family, key)\n response = AGIResponse.new\n command_str = \"DATABASE DEL #{family} #{key}\"\n begin\n response.native = execute(command_str)\n rescue AGITimeoutError, AGICommandError, AGIHangupError\n raise\n end\n if response.native == -1 then\n raise AGIChannelError.new(@last_response, \"Channel Failure in (#{command_str})\")\n elsif response.native == 1 then\n response.success = true\n end\n return response\n end",
"def meterpreter_registry_deletekey(key, view)\n begin\n root_key, base_key = session.sys.registry.splitkey(key)\n perms = meterpreter_registry_perms(KEY_WRITE, view)\n deleted = session.sys.registry.delete_key(root_key, base_key, perms)\n return deleted\n rescue Rex::Post::Meterpreter::RequestError => e\n return nil\n end\n end",
"def del\n redis do |conn|\n conn.multi do |pipeline|\n pipeline.zrem(DIGESTS, key.digest)\n pipeline.del(key.digest, key.queued, key.primed, key.locked, key.info)\n end\n end\n end",
"def delete_api_key!(key, opts = {})\n response = delete_api_key(key, opts)\n\n response.wait(opts)\n end",
"def delete_entry(key, **options); end",
"def delete(key)\n raise \"Method not implemented. Called abstract class.\"\n end",
"def delete\n client.delete_access_key(resource_options)\n nil\n end",
"def delete_by_org_key_and_service_key_and_version(org_key, service_key, version)\n HttpClient::Preconditions.assert_class('org_key', org_key, String)\n HttpClient::Preconditions.assert_class('service_key', service_key, String)\n HttpClient::Preconditions.assert_class('version', version, String)\n @client.request(\"/#{CGI.escape(org_key)}/#{CGI.escape(service_key)}/#{CGI.escape(version)}\").delete\n nil\n end",
"def delete(key)\n unimplemented\n end",
"def delete_by_key(key)\n HttpClient::Preconditions.assert_class('key', key, String)\n @client.request(\"/organizations/#{CGI.escape(key)}\").delete\n nil\n end",
"def delete_bucket( bucket )\n @jservice.delete_bucket( bucket.jbucket )\n end",
"def delete request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/regions/#{request_pb.region}/routers/#{request_pb.router}\"\n\n query_string_params = {}\n query_string_params[\"requestId\"] = request_pb.request_id.to_s if request_pb.request_id && request_pb.request_id != \"\"\n\n response = @client_stub.make_delete_request(\n uri: uri,\n params: query_string_params,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end",
"def delete key\n slot = _find_slot(key)\n return nil if !@data[slot]\n value = @data[slot+1]\n @data[slot] = DELETED\n @data[slot+1] = nil\n\n # Unlink record\n n = @data[slot+2]\n prev = @data[slot+3]\n if prev\n @data[prev+2] = n\n end\n if n\n @data[n+3] = prev\n end\n if @first == slot\n @first = n\n end\n if @last == slot\n @last = prev\n end\n\n # FIXME: It fails without this, which indicates a bug.\n #@length -= 1\n value\n end",
"def delete\n @mapper.delete(@remote_key)\n\n forget\n end",
"def delete(uuid, key)\n request(method: 'DELETE', uri: \"/files/#{uuid}/metadata/#{key}/\")\n end",
"def delete( key )\n fail NotImplementedError\n end",
"def remove_broker_auth_key(gear)\n args = build_base_gear_args(gear)\n result = execute_direct(@@C_CONTROLLER, 'broker-auth-key-remove', args)\n parse_result(result, gear)\n end",
"def delete_key(id)\n @encryption_io.delete_key(id)\n end",
"def delete options = {}\n ensure_connection!\n resp = connection.delete_bucket name, options\n if resp.success?\n true\n else\n ApiError.from_response(resp)\n end\n end",
"def purge_request(key)\n @queue.each do |identity,worker|\n worker.request_queue.delete key\n end\n end",
"def delete(key)\n doozer_pool.with_connection do |doozer|\n doozer.delete(full_key(key))\n end\n end",
"def delete_key_pair(name)\n delete(\"tenants/#{tenant}/sshkeys/#{name}\")\n end",
"def delete(resource, key)\n @cache[resource].delete(key)\n end",
"def del(key)\n @first.del(key)\n end",
"def hdel(key, *fields)\n fields.flatten!(1)\n send_command([:hdel, key].concat(fields))\n end",
"def delete request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/zones/#{request_pb.zone}/disks/#{request_pb.disk}\"\n\n query_string_params = {}\n query_string_params[\"requestId\"] = request_pb.request_id.to_s if request_pb.request_id && request_pb.request_id != \"\"\n\n response = @client_stub.make_delete_request(\n uri: uri,\n params: query_string_params,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end"
] | [
"0.7128815",
"0.70396614",
"0.6782836",
"0.6631057",
"0.6541163",
"0.633033",
"0.6293411",
"0.6293411",
"0.6293411",
"0.6293411",
"0.6293411",
"0.62906814",
"0.62820756",
"0.6280255",
"0.6275988",
"0.62635785",
"0.6246439",
"0.6196306",
"0.6108938",
"0.6104523",
"0.61007875",
"0.60964435",
"0.6083133",
"0.60705036",
"0.6068054",
"0.6045095",
"0.6037755",
"0.60312283",
"0.6024205",
"0.60221523",
"0.6018319",
"0.60180646",
"0.59871006",
"0.598262",
"0.5966675",
"0.59653366",
"0.5959127",
"0.5948345",
"0.59412575",
"0.58953696",
"0.58922505",
"0.5886977",
"0.5883712",
"0.588326",
"0.5883015",
"0.5882195",
"0.5882103",
"0.58788633",
"0.58730906",
"0.5872228",
"0.5853563",
"0.5832962",
"0.5831015",
"0.5826514",
"0.5821976",
"0.57938045",
"0.57938045",
"0.57857436",
"0.5785633",
"0.57848275",
"0.5760732",
"0.57541203",
"0.5729714",
"0.57232994",
"0.5722223",
"0.57197857",
"0.5718302",
"0.57112956",
"0.57028735",
"0.57019055",
"0.5701751",
"0.56965214",
"0.56965214",
"0.56848127",
"0.5644025",
"0.56323195",
"0.5623307",
"0.5621376",
"0.56209284",
"0.5618911",
"0.56181467",
"0.56076294",
"0.55996174",
"0.55937237",
"0.5592958",
"0.5590466",
"0.5589445",
"0.5576604",
"0.5576582",
"0.5543176",
"0.55412984",
"0.5536466",
"0.55165964",
"0.5512247",
"0.55112743",
"0.55105305",
"0.5504354",
"0.5500002",
"0.5495907",
"0.54945314"
] | 0.8234502 | 0 |
Sends a MapReduce operation to riak, using RpbMapRedReq, and returns the Response/phases. | def map_reduce_request(mr_request, content_type)
request = Riakpb::RpbMapRedReq.new
request.request = mr_request
request.content_type = content_type
response = rpc.request(
Util::MessageCode::MAP_REDUCE_REQUEST,
request
)
return(response)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mapred(mr, &block)\n results = []\n inputs = []\n\n # Generate the list of objects to act as inputs into the map/reduce functions\n if mr.inputs.is_a?(String)\n bucket = mr.inputs\n list_keys(bucket).each do |key|\n inputs << [bucket, key]\n end\n elsif mr.inputs.is_a?(Hash)\n bucket = mr.inputs[:bucket]\n if index = mr.inputs[:index]\n if mr.inputs[:key]\n inputs.concat(get_index(bucket, index, key))\n else\n inputs.concat(get_index(bucket, index, mr.inputs[:start]..mr.inputs[:end]))\n end\n else\n raise NotImplementedError, 'Key filters are not implemented for map-reduce processes'\n end\n else\n inputs.concat(mr.inputs)\n end\n\n # Run the map/reduce functions\n mr.query.each_with_index do |phase, index|\n case phase.type\n when :map\n result = []\n inputs.each do |input|\n object = mapred_object(*input)\n result.concat(run_mapred_phase(phase, object))\n end\n when :reduce\n result = run_mapred_phase(phase, inputs)\n when :link\n raise NotImplementedError, 'Link walking is deprecated and will not be supported'\n end\n\n # Track results, use last result as input to the next function\n if phase.keep\n results << result\n elsif index == mr.query.length - 1\n results << []\n end\n \n inputs = result\n end\n\n results.length == 1 ? results[0] : results\n end",
"def map_reduce(source_collection_name,map, reduce, opts={})\n\n map = BSON::Code.new(map) unless map.is_a?(BSON::Code)\n reduce = BSON::Code.new(reduce) unless reduce.is_a?(BSON::Code)\n\n hash = BSON::OrderedHash.new\n hash['mapreduce'] = source_collection_name\n hash['map'] = map\n hash['reduce'] = reduce\n hash.merge! opts\n\n result = database.command(hash)\n unless result[\"ok\"] == 1\n raise Mongo::OperationFailure, \"map-reduce failed: #{result['errmsg']}\"\n end\n\n result\n end",
"def map_reduce(map, reduce, options = {})\n directed(options).map_reduce(map, reduce, options)\n end",
"def _rl_dispatch(key, map)\r\n @_rl_dispatching_keymap = map\r\n return _rl_dispatch_subseq(key, map, false)\r\n end",
"def run\n puts \"Starting a new map reduce instance.\"\n\n # MAPPING\n puts \"Setting up the mapping process:\"\n\n map_dist = Distributor.from_file @data, 65536\n map_exec = Executor.auto map_dist.work, 'Mapping'\n\n puts \" - Number of chunks: #{map_dist.chunk_count}\"\n puts \" - Size of chunks: #{map_dist.chunk_size}\"\n puts \" - Number of items: #{map_dist.item_count}\"\n\n mapped = map_exec.script { Shell::Python.new @mapper }\n File.open(@st_map, 'w') { |f| f.write(mapped.join)} if @st_map \n\n # SORTING\n sorted = mapped.group_by { |m| m.split(', ')[0] }\n\n if @st_sort\n File.open(@st_sort, 'w') { |f| f.write sorted.values.flatten.join }\n end\n\n # REDUCING\n puts \"Setting up the reducing process:\"\n\n red_dist = Distributor.from_list sorted, 65536\n red_exec = Executor.auto red_dist.work, 'Reducing'\n\n puts \" - Number of chunks: #{red_dist.chunk_count}\"\n puts \" - Size of chunks: #{red_dist.chunk_size}\"\n puts \" - Number of items: #{red_dist.item_count}\"\n\n reduced = red_exec.script { Shell::Python.new @reducer }\n File.open(@st_red, 'w') { |f| f.write(reduced.join)} if @st_red\n end",
"def patch request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/regions/#{request_pb.region}/routers/#{request_pb.router}\"\n body = request_pb.router_resource.to_json\n\n response = @client_stub.make_patch_request(\n uri: uri,\n body: body,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end",
"def run_transfer_job request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_run_transfer_job_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def run_mapred_phase(phase, input)\n args = [input] + (phase.arg || [])\n\n if phase.language == 'javascript'\n args = args.map {|arg| arg.to_json} * ','\n ExecJS.eval(\"(function(){#{MAPRED_BUILTINS};return #{phase.function}(#{args});})()\")\n else\n raise NotImplementedError, \"Map-Reduce functions implemented in #{phase.language} are not supported\"\n end\n end",
"def map(**args)\n params = convert_params(args)\n client.get(\"#{ENDPOINT}/map\", options: params.compact)\n end",
"def map(**args)\n params = convert_params(args)\n client.get(\"#{ENDPOINT}/map\", options: params.compact)\n end",
"def run\n begin\n coll = @klass.collection.map_reduce(formula.map, formula.reduce, { :query => @selector, :out => \"#map_reduce\" } ).find.to_a\n rescue\n raise \"Error: could not execute map reduce function\"\n end\n\n formula.process(coll)\n end",
"def map\n @map_secpack = Tem::Assembler.assemble do |s|\n s.label :_secret\n s.label :_key\n s.data :tem_ubyte, @query_key.to_tem_key\n s.label :_check_bytes\n s.data :tem_ubyte, @check_bytes\n \n # User-provided ranking procedure (secret).\n s.label :_ranking\n yield s\n s.ret\n \n s.entry\n s.ldbc 24\n s.outnew\n # Compute score.\n s.call :_ranking \n # Compute padding.\n s.ldbc 3\n s.ldwc :_nonce\n s.rnd\n s.mcfxb :from => :_check_bytes, :to => :_check,\n :size => @check_bytes.length\n \n # Encrypt output.\n s.ldwc :const => :_key\n s.rdk\n s.kefxb :from => :_id, :size => 23, :to => 0xFFFF\n s.halt\n \n s.label :_plain\n \n # Make room for query attributes.\n @attributes.each do |attribute|\n s.label attribute[:name]\n s.zeros attribute[:type], 1\n end\n # Object ID.\n s.label :_id\n s.zeros :tem_ubyte, 8\n # Object score.\n s.label :score\n s.zeros :tem_short, 1\n # Random nonce to prevent matching map outputs.\n s.label :_nonce\n s.zeros :tem_ubyte, 3\n # Check bytes to prevent malicious input corruption.\n s.label :_check\n s.zeros :tem_ubyte, @check_bytes.length\n \n s.stack 64\n end \n end",
"def request\n @rpc.request\n end",
"def post_run_omr_task_with_http_info(name, action_name, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: OmrApi.post_run_omr_task ...\"\n end\n # verify the required parameter 'name' is set\n if @api_client.config.client_side_validation && name.nil?\n fail ArgumentError, \"Missing the required parameter 'name' when calling OmrApi.post_run_omr_task\"\n end\n # verify the required parameter 'action_name' is set\n if @api_client.config.client_side_validation && action_name.nil?\n fail ArgumentError, \"Missing the required parameter 'action_name' when calling OmrApi.post_run_omr_task\"\n end\n # resource path\n local_var_path = \"/omr/{name}/runOmrTask\".sub('{' + 'name' + '}', name.to_s)\n\n # query parameters\n query_params = {}\n query_params[:'actionName'] = action_name\n query_params[:'storage'] = opts[:'storage'] if !opts[:'storage'].nil?\n query_params[:'folder'] = opts[:'folder'] if !opts[:'folder'].nil?\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = @api_client.object_to_http_body(opts[:'param'])\n auth_names = ['oauth']\n data, status_code, headers = @api_client.call_api(:POST, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'OMRResponse')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: OmrApi#post_run_omr_task\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def request(type, payload = '', opts = {}, &blk)\n raise \"Mapper proxy not initialized\" unless identity && @options\n request = Request.new(type, payload, opts)\n request.from = @identity\n request.token = AgentIdentity.generate\n request.persistent = opts.key?(:persistent) ? opts[:persistent] : @options[:persistent]\n @pending_requests[request.token] = { :result_handler => blk }\n RightLinkLog.info(\"SEND #{request.to_s([:tags, :target])}\")\n @amqp.queue('request', :no_declare => @options[:secure]).publish(@serializer.dump(request))\n end",
"def rover_request(rover_module)\n return rover_module.return_array(make_request(rover_module.build_query))\n end",
"def portmap_qry()\n ret = portmap_req()\n\n begin\n arr = Rex::Encoder::XDR.decode!(ret, Integer, Integer, Integer, String, Integer)\n rescue Rex::ArgumentError\n raise Rex::Proto::SunRPC::RPCError, \"#{rhost}:#{rport} - SunRPC - XDR decoding failed in #{__callee__}\"\n end\n\n if arr[1] != MSG_ACCEPTED || arr[4] != SUCCESS || arr[5] == 0\n progname = progresolv(rpcobj.program)\n err = \"Query for program #{rpcobj.program} [#{progname}] failed: \"\n case arr[4]\n when PROG_UMAVAIL then err << \"Program Unavailable\"\n when PROG_MISMATCH then err << \"Program Version Mismatch\"\n when PROC_UNAVAIL then err << \"Procedure Unavailable\"\n when GARBAGE_ARGS then err << \"Garbage Arguments\"\n else err << \"Unknown Error\"\n end\n raise ::Rex::Proto::SunRPC::RPCError, \"#{rhost}:#{rport} - SunRPC - #{err}\"\n end\n\n return ret\n end",
"def map_actions\n actions = []\n return actions if @unmapped_items.empty?\n free_tems_with_sec(:mapper).each do |tem|\n break unless item = @unmapped_items.pop\n @free_tems.delete [@rindex_tems[tem], tem]\n actions.push :action => :map, :item => item, :with => tem,\n :output_id => next_output_id\n end\n actions\n end",
"def request(mc, pb_msg=nil)\n clear\n\n @req_message_code = mc\n @response = RESPONSE_CLASS_FOR[mc].new unless RESPONSE_CLASS_FOR[mc].nil?\n\n with_socket do |socket|\n begin\n begin\n @req_message = assemble_request mc, pb_msg.serialize_to_string\n rescue NoMethodError\n @req_message = assemble_request mc\n end\n\n socket.write(@req_message)\n self.parse_response socket.sysread(@limit)\n\n end while(false == (@response[:done] rescue true))\n\n socket.flush\n end # with_socket\n\n return(@response)\n end",
"def done_mapping(action)\n @free_tems[[@rindex_tems[action[:with]], action[:with]]] = true\n @reduce_queue[action[:output_id]] = true\n end",
"def patch_rule request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n uri, body, query_string_params = transcode_patch_rule_request request_pb\n response = @client_stub.make_post_request(\n uri: uri,\n body: body,\n params: query_string_params,\n options: options\n )\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n result\n end",
"def run_data_scan request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_run_data_scan_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::Dataplex::V1::RunDataScanResponse.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def insert request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/regions/#{request_pb.region}/routers\"\n body = request_pb.router_resource.to_json\n\n response = @client_stub.make_post_request(\n uri: uri,\n body: body,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end",
"def dispatch_request(req)\n # /calculator/add\n #\n # gets split into nil, calculator as prefix and add as method name\n # that is called on actor instance\n #\n # TODO: how about /math/calculator/add and handling namespaced\n # actors or methods with / in them? It may be an issue for a larger\n # nanites cluster :/\n _, prefix, meth = req.type.split('/')\n begin\n actor = @actors[prefix]\n res = actor.send((meth.nil? ? \"index\" : meth), req.payload)\n rescue Exception => e\n res = \"#{e.class.name}: #{e.message}\\n #{e.backtrace.join(\"\\n \")}\"\n end\n Result.new(req.token, req.reply_to, res, agent.identity) if req.reply_to\n end",
"def mapred_object(bucket = nil, key = nil, data = nil, content_type = nil)\n robject = fetch_object(bucket, key)\n\n {\n 'bucket_type' => 'undefined',\n 'bucket' => bucket,\n 'key' => key,\n 'vclock' => robject.vclock,\n 'values' => [\n {\n 'metadata' => {\n 'X-Riak-VTag' => robject.etag,\n 'content-type' => content_type || robject.content_type,\n 'index' => robject.indexes,\n 'X-Riak-Last-Modified' => robject.last_modified.rfc822,\n 'charset' => robject.raw_data.encoding.name\n },\n 'data' => data || robject.raw_data\n }\n ]\n }\n end",
"def read_mrp\n $MRP_FILE = $PRJ_NAME + \"_map.mrp\"\n f = open($MRP_FILE,\"r\")\n while line = f.gets\n if /ERROR/ =~ line\n /LOC=(.*)\\)/ =~ line # pick up Slice name\n $ERROR_SLICE << $1\n end\n end\n f.close\n $ERROR_SLICE.uniq!\nend",
"def post_read_result!\n @operation = READ_REQUEST\n post_outcome_request\n end",
"def call(env)\n params = Rack::Request.new(env).params\n reduction = @reducer.apply(params)\n @app.call env.merge(@key => reduction)\n end",
"def request(type, payload = '', opts = {}, &blk)\n raise \"Mapper proxy not initialized\" unless identity && options\n request = Request.new(type, payload, opts)\n request.from = identity\n request.token = Identity.generate\n request.persistent = opts.key?(:persistent) ? opts[:persistent] : options[:persistent]\n pending_requests[request.token] = \n { :intermediate_handler => opts[:intermediate_handler], :result_handler => blk }\n amqp.fanout('request', :no_declare => options[:secure]).publish(serializer.dump(request))\n end",
"def write_rmap rmap\n\nend",
"def reset request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_reset_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def run(req, res)\n end",
"def km_reduce_reacid(acc, crt)\n return acc if crt[\"reaction\"].nil?\n k = crt[\"entry\"][0].match(/^(?<id>M\\d{5})/)[:id]\n r = km_get_reacid(crt[\"reaction\"])\n return acc if r.empty?\n acc[k] = r\n return acc\nend",
"def run(prg_ary, inp = STDIN, out = $DEFAULT_OUTPUT)\n idx = 0\n while OPCODES.include?(o = op(prg_ary[idx]))\n i = OPCODE_IMPLS[o].call(prg_ary, idx, modes(prg_ary[idx]), inp, out)\n idx = JMP_OPS.include?(o) ? i : idx + OP_LENS[o]\n end\n # puts prg_ary[idx] == 99 ? \"HALT\" : \"UNEXPECTED OPCODE #{ prg_ary[idx] }\"\n prg_ary\n end",
"def recall_map_view\n get :map_view\n end",
"def main\n \n require 'benchmark'\n result_hash = nil\n \n time = Benchmark.measure { result_hash = build_pcrs_hash }\n show do\n title \"operations batched\"\n note \"#{time.to_s}\" \n end\n \n log_info result_hash\n \n {}\n end",
"def do_request(request, want_reply, data); end",
"def roar(payload)\n https = Net::HTTP.new(@request[:uri].host, @request[:uri].port)\n https.use_ssl = @request[:ssl]\n https.post(@request[:uri].path, cage(payload), { 'pnthr' => @request[:id] })\n end",
"def add_rule request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n uri, body, query_string_params = transcode_add_rule_request request_pb\n response = @client_stub.make_post_request(\n uri: uri,\n body: body,\n params: query_string_params,\n options: options\n )\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n result\n end",
"def cmvc_extract_changed rmap\n\n raise \"oops, not done\"\nend",
"def get_run request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_get_run_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::DataCatalog::Lineage::V1::Run.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def resume_replication request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_resume_replication_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def main\n require 'benchmark'\n result_hash = nil\n \n time = Benchmark.measure { result_hash = build_pcrs_hash }\n show do\n title \"operations batched\"\n note \"#{time.to_s}\" \n end\n \n log_info result_hash\n {}\n end",
"def map(&block)\n @logger.debug(\"starting map in #{@name} with id #{Thread.current.object_id}\")\n @running = true\n manage_workers(&block) while @running\n @result.close\n @logger.debug(\"finishing map in #{@name} with id #{Thread.current.object_id}\")\n @result\n end",
"def get request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/regions/#{request_pb.region}/routers/#{request_pb.router}\"\n\n response = @client_stub.make_get_request(\n uri: uri,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Router.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end",
"def map_ingredients_to_grocery_products_with_http_info(map_ingredients_to_grocery_products_request, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: IngredientsApi.map_ingredients_to_grocery_products ...'\n end\n # verify the required parameter 'map_ingredients_to_grocery_products_request' is set\n if @api_client.config.client_side_validation && map_ingredients_to_grocery_products_request.nil?\n fail ArgumentError, \"Missing the required parameter 'map_ingredients_to_grocery_products_request' when calling IngredientsApi.map_ingredients_to_grocery_products\"\n end\n # resource path\n local_var_path = '/food/ingredients/map'\n\n # query parameters\n query_params = opts[:query_params] || {}\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n content_type = @api_client.select_header_content_type(['application/json'])\n if !content_type.nil?\n header_params['Content-Type'] = content_type\n end\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body] || @api_client.object_to_http_body(map_ingredients_to_grocery_products_request)\n\n # return_type\n return_type = opts[:debug_return_type] || 'Array<MapIngredientsToGroceryProducts200ResponseInner>'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || ['apiKeyScheme']\n\n new_options = opts.merge(\n :operation => :\"IngredientsApi.map_ingredients_to_grocery_products\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: IngredientsApi#map_ingredients_to_grocery_products\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def retry_build request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_retry_build_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def get_replication request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_get_replication_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::NetApp::V1::Replication.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def postMultipackMap_pin( multipack_id, filedata, mapPinOffsetX, mapPinOffsetY)\n params = Hash.new\n params['multipack_id'] = multipack_id\n params['filedata'] = filedata\n params['mapPinOffsetX'] = mapPinOffsetX\n params['mapPinOffsetY'] = mapPinOffsetY\n return doCurl(\"post\",\"/multipack/map_pin\",params)\n end",
"def train_flow request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_train_flow_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def map_cp_r(options={}, &block)\n map_send(:cp_r, options={}, &block)\n end",
"def post\n @response_body = make_request(\"#{api_url}#{endpoint}\", request_body.to_json)\n puts \"GLIMR POST: #{endpoint} - #{request_body.to_json}\" if ENV.key?('GLIMR_API_DEBUG')\n end",
"def execute(req_hash, data, start)\n #This is a stub, used for indexing\n end",
"def run(prg_ary)\n idx = 0\n while OPCODES.include?(o = op(prg_ary[idx]))\n i = OPCODE_IMPLS[o].call(prg_ary, idx, modes(prg_ary[idx]))\n idx = JMP_OPS.include?(o) ? i : idx + OP_LENS[o]\n end\n # puts prg_ary[idx] == 99 ? \"HALT\" : \"UNEXPECTED OPCODE #{ prg_ary[idx] }\"\n prg_ary\n end",
"def process(request)\n XMLRPCRequest.new(*XMLRPC::Marshal.load_call(request.raw_post))\n end",
"def update_run request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_update_run_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::DataCatalog::Lineage::V1::Run.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def update request_pb, options:, &block\n uri = \"/compute/v1/projects/#{request_pb.project}/regions/#{request_pb.region}/routers/#{request_pb.router}\"\n body = request_pb.router_resource.to_json\n\n response = @client_stub.make_put_request(\n uri: uri,\n body: body,\n options: options,\n )\n\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n\n result\n end",
"def run(req, res)\n route_params = self.make_match_hash(req)\n controller = @controller_class.new(req, res, route_params)\n controller.invoke_action(@action_name)\n end",
"def run\n @cluster.retriable(api_name) do\n process(retriable_requests)\n\n # Stop retrying when there are no more requests to retry\n retriable_requests.empty?\n end\n\n responses\n end",
"def map_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: UsageApi.map ...'\n end\n # resource path\n local_var_path = '/map'\n\n # query parameters\n query_params = opts[:query_params] || {}\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n content_type = @api_client.select_header_content_type(['application/json'])\n if !content_type.nil?\n header_params['Content-Type'] = content_type\n end\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:'map_alias'])\n\n # return_type\n return_type = opts[:debug_return_type] || 'Object'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || []\n\n new_options = opts.merge(\n :operation => :\"UsageApi.map\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: UsageApi#map\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def run_access_report request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_run_access_report_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Analytics::Admin::V1alpha::RunAccessReportResponse.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def get_redemption_request_actions\r\n\r\n # prepare query url\r\n _query_builder = Configuration.base_uri.dup\r\n _query_builder << '/utilities/redemption-request-actions'\r\n _query_url = APIHelper.clean_url _query_builder\r\n\r\n # prepare headers\r\n _headers = {\r\n 'accept' => 'application/json',\r\n 'Content-Type' => Configuration.content_type\r\n }\r\n\r\n # prepare and execute HttpRequest\r\n _request = @http_client.get _query_url, headers: _headers\r\n CustomHeaderAuth.apply(_request)\r\n _context = execute_request(_request)\r\n validate_response(_context)\r\n\r\n # return appropriate response type\r\n decoded = APIHelper.json_deserialize(_context.response.raw_body) if not (_context.response.raw_body.nil? or _context.response.raw_body.to_s.strip.empty?)\r\n return decoded\r\n end",
"def update_replication request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_update_replication_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def patch request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n uri, body, query_string_params = transcode_patch_request request_pb\n response = @client_stub.make_patch_request(\n uri: uri,\n body: body,\n params: query_string_params,\n options: options\n )\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n result\n end",
"def patch request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n uri, body, query_string_params = transcode_patch_request request_pb\n response = @client_stub.make_patch_request(\n uri: uri,\n body: body,\n params: query_string_params,\n options: options\n )\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n result\n end",
"def run_protocol\n program_name = validate_operations\n composition = PCRComposition.new(program_name: program_name)\n program = PCRProgram.new(program_name: program_name, volume: composition.volume)\n\n # TODO: make this method smart enough to deal\n if program.program_name =~ /$lib_/\n initialize_fragment_libraries\n end\n\n report_errors\n return {} unless operations.running.present?\n\n sorted_ops = sort_ops\n prepare_materials(sorted_ops, composition)\n sorted_ops.make\n\n # TODO: create a MasterMix class that handles variables like this\n # should also handle MAKE_EXTRA calculations\n stamp_columns = program.program_name == 'lib_qPCR2' ? 8 : nil\n set_up_reactions(sorted_ops, composition, stamp_columns)\n\n run_test_and_real(sorted_ops, program, stamp_columns)\n\n if program.program_name == \"qPCR2\"\n associate_barcodes(ops: sorted_ops, input_name: REVERSE_PRIMER, output_name: FRAGMENT)\n elsif program.program_name =~ /$lib_/\n associate_library_data(sorted_ops)\n end\n\n associate_bins(ops: sorted_ops, input_name: TEMPLATE, output_name: FRAGMENT)\n associate_volumes(ops: sorted_ops, output_name: FRAGMENT, volume: composition.volume)\n\n sorted_ops.each { |op| op.output(FRAGMENT).item.move(NGS_BOX_NAME) }\n\n pcr_cleanup\n operations.store\n\n # remaining_primers = check_primer_volumes(FORWARD_PRIMER, REVERSE_PRIMER)\n check_primer_volumes(sorted_ops, FORWARD_PRIMER, REVERSE_PRIMER)\n\n display_output_table(sorted_ops)\n\n get_protocol_feedback\n\n display_mapping(TEMPLATE, FRAGMENT, sorted_ops) if debug\n\n return {}\n end",
"def rq(data=nil)\n if @preprocessor\n data= @preprocessor.call(data)\n end\n Wowwee::Mip::Protocol::Rq.new(@code, data)\n end",
"def control\n @responses = build_params.map { |request_params| lookup(request_params) }\n end",
"def invoke_request(rpc_method, *args)\n 0.upto(args.size).each { |i| args[i] = args[i].to_s if args[i].is_a?(Symbol) }\n message = RequestMessage.new :method => rpc_method,\n :args => args,\n :headers => @message_headers\n\n # we serialize / unserialze messages to ensure local node complies\n # to same json-rpc restrictions as other nodes\n message = RequestMessage.new :message => message.to_s,\n :headers => @message_headers\n\n result = Dispatcher.dispatch_request(message.jr_method,\n :method_args => message.jr_args,\n :headers => @message_headers,\n :rjr_node => self,\n :rjr_node_id => @node_id,\n :rjr_node_type => @node_type,\n :rjr_callback =>\n LocalNodeCallback.new(:node => self,\n :headers => @message_headers))\n response = ResponseMessage.new(:id => message.msg_id,\n :result => result,\n :headers => @message_headers)\n\n # same comment on serialization/unserialization as above\n response = ResponseMessage.new(:message => response.to_s,\n :headers => @message_headers)\n return Dispatcher.handle_response(response.result)\n end",
"def start request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_start_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def process_response\n job = message.job\n job.data = message.data\n job.message = message.message\n\n if message.ok?\n job.proceed!\n else\n job.error!\n end\n end",
"def create_replication request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_create_replication_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def rr_route client, server_type, msg, &block\n end",
"def request(params=Hash.new, &result_cbk)\n\n cmd = params.delete :cmd\n prefix = params.delete :prefix\n cont = params.delete :cont\n offset = params.delete :offset\n len = params.delete :len\n\n if cont.is_a? String\n cont=request_string(cont)\n elsif cont.is_a? Integer\n cont=request_int(cont)\n end\n raise ArgumentError, \":cont should be an Enumerable\" if !cont.nil? and !cont.is_a? Enumerable\n if len.nil?\n len=(cont.nil?) ? 0 : cont.length\n end\n\n offset||=0\n\n\n if (!cont.nil?)\n raise \":cont shouldn't contain anything but Fixnum\" if cont.any? {|v| !v.is_a? Fixnum}\n if (offset>=cont.length)\n cont=nil;len=0\n elsif (len>cont.length-offset)\n len=cont.length-offset\n end\n end\n offset=0 if offset<0\n len=0 if len<0\n contlen=(cont.nil?) ? 0 : len\n contlen+=prefix.length if (!prefix.nil? and prefix.length>0)\n\n hdr=Array.new(16)\n set_int(cmd,hdr,0)\n set_int(contlen,hdr,4);\n 8.upto(15) {|i| hdr[i]=0}\n if (cmd!=-1)\n io.write(hdr.pack(\"C*\"))\n if (!prefix.nil? && prefix.length>0)\n io.write(prefix.pack(\"C*\"))\n debug \"SEND PREFIX #{prefix}\"\n end\n if (!cont.nil? and cont.length>0)\n debug \"SEND CONTENT #{cont.slice(offset, len)} (#{offset},#{len})\"\n io.write(cont.slice(offset, len).pack(\"C*\"))\n end\n end\n\n io.on_recv(16) do |chunk|\n #\"Expecting 16 bytes...\" if $DEBUG\n ih = chunk.unpack(\"C*\")\n if (ih.length != 16)\n debug \"Received #{ih.length} of expected 16.\"\n result_cbk.call(nil)\n return\n end\n debug \"Answer: #{ih.to_s}\"\n\n rep=get_int(ih, 0);\n rl =get_int(ih,4);\n\n debug \"rep: #{rep} #{rep.class} #{rep & 0x00FFFFFF}\"\n debug \"rl: #{rl} #{rl.class}\"\n\n if (rl>0)\n ct=Array.new();\n io.on_recv(rl) do |chunk|\n ct = chunk.unpack(\"C*\")\n debug \"ct: #{ct.size}\"\n result_cbk.call(Rserve::Packet.new(rep, ct))\n end\n else\n result_cbk.call(Rserve::Packet.new(rep, nil))\n end\n end\n end",
"def get_data_scan_job request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_get_data_scan_job_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::Dataplex::V1::DataScanJob.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def request(name,job)\n rz_send(service_socket(name),[JSON.dump(job)])\n self\n end",
"def post_run_omr_task(name, action_name, opts = {})\n data, _status_code, _headers = post_run_omr_task_with_http_info(name, action_name, opts)\n return data\n end",
"def _reduce(klass, seq_op, comb_op, zero_value=nil)\n if seq_op.nil?\n # Partitions are already reduced\n rdd = self\n else\n rdd = new_rdd_from_command(klass, seq_op, zero_value)\n end\n\n # Send all results to one worker and combine results\n rdd = rdd.coalesce(1).compact\n\n # Add the same function to new RDD\n comm = rdd.add_command(klass, comb_op, zero_value)\n comm.deserializer = @command.serializer\n\n # Value is returned in array\n PipelinedRDD.new(rdd, comm).collect[0]\n end",
"def run\n messages = {'outputs' => outputs}\n\n if outputs.include? 'trello'\n messages['trello'] = enqueue_trello\n end\n\n if outputs.include? 'jira'\n messages['jira'] = enqueue_jira\n end\n\n return [ACCEPTED, {}, messages]\n end",
"def run\n messages = {'outputs' => outputs}\n\n if outputs.include? 'trello'\n messages['trello'] = enqueue_trello\n end\n\n if outputs.include? 'jira'\n messages['jira'] = enqueue_jira\n end\n\n return [ACCEPTED, {}, messages]\n end",
"def reverse_replication_direction request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_reverse_replication_direction_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def restore_service request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_restore_service_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Longrunning::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def request\n @req\n end",
"def remapped_reads(input_file, output_file, read_length, mm=2)\n\t\tremapped = {}\n\t\t\n\t\t# Filter remapped reads\n\t\tinput_file.each do |line|\n\t\t\tmdz = line.match(/MD:Z:\\S*/).to_s\n\t\t\tline = line.strip.split(/\\s+/)\n\t\t\tqname, mate = line[0].split('/')\n\t\t\tpos = line[2].split(':')\n\t\t\tcigar = line[5]\n\t\n\t\t\tif !remapped.has_key?(qname) && Alignment.max_mismatches?(mdz, mm) && cigar == \"#{read_length}M\"\n\t\t\t\tremapped[qname] = [pos, mate]\n\t\t\telse\t\n\t\t\t\tremapped.delete(qname)\n\t\t\tend\n\t\tend\n\n\t\t# Output\n\t\tFile.open(output_file, 'w') do |output|\n\t\t\tremapped.each {|k, v| output.puts [\"#{k}/#{v[-1]}\", v[0]].join(\"\\t\")}\n\t\tend\n\t\t$logfile.puts \"#{Time.new.strftime(\"%c\")}: Found remapped reads.\"\n\tend",
"def perform_op(method, req_hash, options={}, &blk)\n set_defaults(options)\n max_retries = options[:max_retries] || 5\n max_follows = options[:max_follows] || 10\n if options[:follow_count] && options[:follow_count] >= max_follows\n raise Rest::RestError, \"Too many follows. #{options[:follow_count]}\"\n end\n current_retry = 0\n current_follow = 0\n success = false\n tries = 0\n res = nil\n # todo: typhoeus does retries in the library so it shouldn't do retries here. And we should use the max_retries here as a parameter to typhoeus\n while current_retry < max_retries && current_follow < max_follows do\n tries += 1\n begin\n res = yield blk\n res.tries = tries\n if res.code >= 300 && res.code < 400\n # try new location\n #p res.headers\n loc = res.headers[\"location\"]\n @logger.debug \"#{res.code} Received. Trying new location: #{loc}\"\n if loc.nil?\n raise InvalidResponseError.new(\"No location header received with #{res.code} status code!\")\n end\n # options.merge({:max_follows=>options[:max_follows-1]}\n options[:follow_count] ||= 0\n options[:follow_count] += 1\n res = perform_op(method, req_hash, options) do\n res = @wrapper.send(method, loc, req_hash)\n end\n #puts 'X: ' + res.inspect\n return res\n end\n # If it's here, then it's all good\n break\n rescue Rest::HttpError => ex\n if ex.code == 503\n raise ex if current_retry == max_retries - 1\n\n pow = (4 ** (current_retry)) * 100 # milliseconds\n #puts 'pow=' + pow.to_s\n s = rand * pow\n #puts 's=' + s.to_s\n sleep_secs = 1.0 * s / 1000.0\n #puts 'sleep for ' + sleep_secs.to_s\n current_retry += 1\n @logger.debug \"#{ex.code} Received. Retrying #{current_retry} out of #{max_retries} max in #{sleep_secs} seconds.\"\n sleep sleep_secs\n else\n raise ex\n end\n end\n end\n res\n end",
"def index\n @rappers = Rapper.all\n end",
"def reducer; end",
"def operate(bucket, key, bucket_type, operation, options = {})\n bucket = backend.client.bucket(bucket) unless bucket.is_a?(Bucket)\n operations = Array(operation)\n\n # Get the current data for this key\n data = backend.crdt_loader.load(bucket, key, bucket_type)\n datatype = operations[0].type\n\n # Process each operation on the data\n operations.each do |operation|\n data = merge(data, datatype, operation.value)\n end\n\n # Store the value for future access\n robject = RObject.new(bucket, key)\n robject.raw_data = Marshal.dump(data)\n robject.content_type = \"application/riak_#{datatype}\"\n robject.store(:type => bucket_type)\n\n # Wrap the result in an API compatible with Riak\n Result.new(key, data, SecureRandom.uuid)\n end",
"def move request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n uri, _body, query_string_params = transcode_move_request request_pb\n response = @client_stub.make_post_request(\n uri: uri,\n params: query_string_params,\n options: options\n )\n result = ::Google::Cloud::Compute::V1::Operation.decode_json response.body, ignore_unknown_fields: true\n\n yield result, response if block_given?\n result\n end",
"def riak\n @riak ||= Riak::Client.new(host: TestChamber.target_url.split('/').last, pb_port: 8087, protocol: 'pbc')\n end",
"def remap(map)\n @tree.free if @tree\n @tree = R3::Tree.new(map.size)\n\n map.each do |method_and_route, app|\n method, route, data = method_and_route\n\n raise ArgumentError, 'path need to start with /' unless route[0] == '/'\n\n @tree.add(route, method, [app, data])\n end\n\n @tree.compile\n end",
"def process_request req, res\n req_headers = req.header\n req_query = req.query\n req_body = Oaf::HTTPServer.get_request_body req\n file = Oaf::Util.get_request_file(@options[:path], req.path,\n req.request_method, @options[:default_response])\n out = Oaf::Util.get_output(file, req.path, req_headers, req_body,\n req_query)\n res_headers, res_status, res_body = Oaf::HTTPServer.parse_response out\n Oaf::HTTPServer.set_response! res, res_headers, res_body, res_status\n end",
"def send_service_input\n # Send the request\n base64Input = params[:project][:input]\n response = RestClient.post(SERVICE_REQUEST_URL,\n {\n :id => @project[:id],\n :options => @project[:service_options],\n :input => base64Input\n }.to_json, {content_type: :json, accept: :json})\n # Set the project's eta to the SMACK server's predicted processing time\n return JSON.parse(response.body)['eta']\n end",
"def map!\n end",
"def redo!\n send_request\n end",
"def receive_data(job)\n begin\n puts \"Running ReduceRunner\"\n intermediate_file, proc, output = YAML.load(job)\n runner = ReduceRunner.new(intermediate_file, proc, output)\n\n thread = Proc.new { runner.reduce! }\n callback = Proc.new { send_data(runner.output) }\n EM.defer(thread, callback)\n rescue => e\n pp [:red_server, e]\n end\n end",
"def kp_reduce_modid(acc, crt)\n return acc if crt[\"module\"].nil?\n k = crt[\"entry\"][0].match(/^(?<id>(map|rn)\\d{5})/)[:id]\n m = kp_get_modid(crt[\"module\"])\n return acc if m.empty?\n acc[k] = m\n return acc\nend",
"def run(req, res)\n controller = controller_class.new(req, res, route_params(req))\n controller.invoke_action(action_name)\n end",
"def create_run request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_create_run_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::DataCatalog::Lineage::V1::Run.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def get_request(bucket, key, quorum=nil)\n request = Riakpb::RpbGetReq.new({:bucket => bucket, :key => key})\n\n quorum ||= @read_quorum\n unless quorum.blank?\n quorum = quorum.to_i\n request.r = quorum\n end\n\n\n response = rpc.request(\n Util::MessageCode::GET_REQUEST,\n request\n )\n\n return(response)\n end"
] | [
"0.60963875",
"0.540774",
"0.53623384",
"0.51605296",
"0.5030062",
"0.48076388",
"0.47771114",
"0.4710285",
"0.47099197",
"0.47099197",
"0.47029185",
"0.46856683",
"0.46546808",
"0.46464658",
"0.46345624",
"0.4597326",
"0.45805436",
"0.4570553",
"0.45663828",
"0.4546522",
"0.4544427",
"0.44991863",
"0.44766286",
"0.44678107",
"0.4441012",
"0.44313586",
"0.44221267",
"0.43864417",
"0.43783933",
"0.43712983",
"0.43668726",
"0.43636483",
"0.4358217",
"0.43319184",
"0.43235907",
"0.43195742",
"0.43157715",
"0.43009558",
"0.43000433",
"0.4297594",
"0.42805248",
"0.42748025",
"0.42628446",
"0.4259792",
"0.42442486",
"0.42276347",
"0.42268443",
"0.42219973",
"0.4218216",
"0.42090458",
"0.42089647",
"0.42053133",
"0.42052",
"0.4202863",
"0.42006695",
"0.41929278",
"0.4191614",
"0.41825235",
"0.4181879",
"0.41753143",
"0.41669235",
"0.41621327",
"0.4159757",
"0.4156073",
"0.4156073",
"0.41442525",
"0.41421348",
"0.41375405",
"0.4128972",
"0.4128412",
"0.41213125",
"0.41201067",
"0.41010004",
"0.41002777",
"0.40968922",
"0.40933394",
"0.4082811",
"0.40793726",
"0.40643176",
"0.40643176",
"0.40641412",
"0.40533727",
"0.4051122",
"0.40492153",
"0.4041595",
"0.40410817",
"0.4039577",
"0.40386158",
"0.4032984",
"0.40324336",
"0.40285423",
"0.40274662",
"0.4026685",
"0.4026211",
"0.40256235",
"0.40208456",
"0.40187135",
"0.4017827",
"0.40177432",
"0.40145516"
] | 0.7805435 | 0 |
[Yes, No, Inactive] application_fee (float) renewal_schedule_in_years, | def map_exam_required
# Return list of required exams split by ,
if self.exam_required
(self.exam_required.join ", ").gsub(/, $/, '')
else
[]
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def application_fee\n self[:application_fee] || (unit_price * (COMMISSION_RATE / 100) + TRANSACTION_COST / 100).round(2) || BigDecimal(0)\n end",
"def assistance_fee\n ROADSIDE_ASSISSTANCE_FEE_PER_DAY * duration\n end",
"def application_fee_without_tax\n application_fee * (1 - tax_rate / 100)\n end",
"def required_annual_savings\n needed_amount_less_savings / years_to_retirement\n end",
"def charge_fee\r\n\t\tif_member = Participant.find_by(participantID: participantID)\r\n\t\tif_course = Course.find_by(courseID: courseID)\r\n\t\t\r\n\t\tif if_course != nil && if_member != nil\r\n\t\t\tearlyBirdTime = if_course.startDate.months_ago(1)\r\n\t\t\tif if_member.expirydate > Date.today\r\n\t\t\t\tif Date.today >= earlyBirdTime && Date.today < if_course.startDate\r\n\t\t\t\t\treturn if_course.earlybirdPrice\r\n\t\t\t\telse\r\n\t\t\t\t\treturn if_course.memberPrice\r\n\t\t\t\tend\r\n\t\t\telse\r\n\t\t\t\treturn if_course.nonmemberPrice\r\n\t\t\tend\r\n\t\tend\r\n\tend",
"def insurance_fee\n (COMMISSION_RATE * INSURANCE_PART_RATE * price).round\n end",
"def appraisal_fee_params\n params.require(:appraisal_fee).permit(:duration_from, :duration_to, :percentual, :fixed_min, :fixed_max, :loan_id)\n end",
"def document_fee\n 0\n end",
"def allowed_to_pay_renewal_member_fee?\n return false if admin?\n\n (current_member? || in_grace_period?) &&\n RequirementsForRenewal.requirements_excluding_payments_met?(self)\n end",
"def tradies_app_fee(price)\n app_fee = price * 0.0025\n if price > 0 && price < 100\n app_fee = price * 0.015\n elsif price >= 100 && price < 1000\n app_fee = price * 0.01\n elsif price >= 1000 && price < 10000\n app_fee = price * 0.005\n elsif price >= 10000\n app_fee = price * 0.0025\n end\n return app_fee\n end",
"def unpaid_grace_period_amount\n total_grace_period_amount - paid_grace_period_amount\n end",
"def overdraft_fee\n @balance -= 30 \n end",
"def calculate_fee\n Application::courses_fee(course_selections_count > 1 ? :multiple : :single)\n end",
"def renewal_eligiblity_determination\n end",
"def referrals_needed_per_month\n 5 * monthly_transaction_goal\n end",
"def transaction_fee\n Money.new(-WITHDRAWAL_FEE_IN_CENTS, self.currency)\n end",
"def better_to_confirm\n ! (self.confirmed && (((Time.zone.now - self.confirmed).to_i / 86400) < 365))\n end",
"def withdrawal_rate\n (youngest_person_retirement_age - 15.0) / 1000.0\n end",
"def set_appraisal_fee\n @appraisal_fee = AppraisalFee.find(params[:id])\n end",
"def annual_salary\n hourly_rate * 1950\n end",
"def annual_bonus\n if @faculty.eligible_for_annual_bonus_payment?(@generation_date)\n last_annual_bonus_paid_on = @faculty.last_annual_bonus_paid_on\n unless last_annual_bonus_paid_on.present?\n last_annual_bonus_paid_on = Date.new(@generation_date.year-1, @faculty.rule_engine(:bonus_payment_month)+1, 1)\n end\n EmployerContribution.belongs_to_employee(@faculty).generated_after(last_annual_bonus_paid_on).inject(0){|sum, contrib| sum+contrib.bonus_payment}\n end\n end",
"def annual_cost_or_base_pay\n case request_model_type\n when 'staff', 'contractor'\n (annual_base_pay_cents / 100.0)\n when 'labor'\n (calculate_annual_cost_in_cents / 100.0)\n else\n logger.error(\"Unknown request model type: #{request_model_type}\")\n 0.00\n end\n end",
"def get_late_fee\n lib = Library.find(self[:library_id])\n max_brw_days = lib.max_borrow_days\n fine = lib.overdue_fine\n\n late_fee = 0\n start_date = self[:start]\n\n if !start_date.nil? && Time.now > start_date + max_brw_days.days\n overdue_days = (Time.now.to_date - (start_date + max_brw_days.days).to_date).to_i\n late_fee = fine * overdue_days\n end\n\n return late_fee\n end",
"def total_fee\n fee + fee2 + fee3 + fee4\n end",
"def profit(cal)\n day_rate = avg_rate_card_amount_cents.round(2)\n mins_tracked = Timing.minute_duration_submitted_for_period_and_client(id, cal.start_date, cal.end_date)\n invoiced_amount = Invoice.amount_cents_invoiced_for_period_and_client(id, cal.start_date, cal.end_date).round(2)\n days_tracked = (hours = mins_tracked.to_s.to_d / account.account_setting.working_day_duration_minutes).round(2)\n\n (invoiced_amount - (days_tracked * day_rate.to_s.to_d)).round(2)\n end",
"def create_application_payment\n Payment.new application: self,\n amount: self.calculate_fee,\n description: \"Application fee (#{pluralize self.course_selections_count, 'course'})\"\n end",
"def franchisee_royalty_pay_slip\n \n end",
"def book_royalty(period='enddate', basis=\"Net receipts\")\n royarray = []\n sales = self.book_sales(period, basis, false) # this calls the royalty calculation for net receipts\n sales.each do |sale|\n royarray << sale.royalty_by_band.inject(0) { |sum, i| sum + i.to_f unless i.nan? || i.nil? }\n end\n book_royalty = royarray.inject(0) { |sum, i| sum +i.to_f }\n end",
"def fee\n params['amount_fee']\n end",
"def fee\n @fee || DEFAULT_FEE\n end",
"def fixed_fee_quantity\n qty = billing_frequency.total_months\n sub_starting_at = subscriber.starting_at\n sub_ending_at = subscriber.ending_at\n if self.reading_type_id == ReadingType::RETIRADA && !self.reading_date.blank?\n sub_ending_at = self.reading_date.to_date\n end\n bp_billing_starting_date = billing_period.billing_starting_date\n bp_billing_ending_date = billing_period.billing_ending_date\n begin\n if sub_starting_at > bp_billing_starting_date && sub_starting_at < bp_billing_ending_date\n # Subscriber registerd during the period\n # qty = (bp_billing_ending_date - sub_starting_at).to_i.days.seconds / 1.month.seconds\n qty = ((bp_billing_ending_date - sub_starting_at).days.seconds / 1.month.seconds).round\n end\n if (!sub_ending_at.nil?) && (sub_ending_at > bp_billing_starting_date && sub_ending_at < bp_billing_ending_date)\n # Subscriber withdrawn during the period\n qty = ((sub_ending_at - bp_billing_starting_date).days.seconds / 1.month.seconds).round\n end\n rescue\n qty = billing_frequency.total_months\n end\n return qty\n end",
"def annual_cost\n (number_of_positions * hourly_rate * hours_per_week * number_of_weeks)\n end",
"def annual_cost\n (number_of_positions * hourly_rate * hours_per_week * number_of_weeks)\n end",
"def technically_paid?\n unconfirmed_value_paid >= value_needed\n end",
"def status\n is_renewal? ? 'Renewal' : 'New Subscripion'\n end",
"def money_approved?\n true\n end",
"def fees\n @fees ||= {\n \"insurance_fee\" => (commission * ASSURANCE_SHARE).round(0),\n \"assistance_fee\" => (ASSISTANCE_COST * rental.duration).round(0)\n }.tap { |fees| fees[\"drivy_fee\"] = commission - fees.values.inject(:+) }\n end",
"def apply_fees\n remove_fees\n unless waive_fees\n #CHALKLE\n self.chalkle_gst_number = Finance::CHALKLE_GST_NUMBER\n self.chalkle_fee = course.chalkle_fee_no_tax\n self.chalkle_gst = course.chalkle_fee_with_tax - chalkle_fee\n \n self.processing_fee = course.processing_fee\n self.processing_gst = course.processing_fee*3/23\n self.processing_fee = course.processing_fee-self.processing_gst\n\n #TEACHER FEE\n if provider_pays_teacher?\n self.teacher_fee = 0\n self.teacher_gst = 0\n else\n if fee_per_attendee?\n self.teacher_fee = course.teacher_cost\n elsif flat_fee?\n confirmed_booking_count = course.bookings.fees_not_waived.paid.confirmed.count\n if confirmed_booking_count > 0\n self.teacher_fee = course.teacher_cost / confirmed_booking_count\n else\n self.teacher_fee = course.teacher_cost\n end\n end\n end\n\n #TEACHER TAX\n if course.teacher.present? && course.teacher.tax_registered?\n self.teacher_gst_number = course.teacher.tax_number\n self.teacher_gst = teacher_fee*3/23\n self.teacher_fee = teacher_fee-teacher_gst\n else\n self.teacher_gst = 0\n self.teacher_gst_number = nil\n end\n\n #PROVIDER\n self.provider_fee = course.provider_fee\n if provider.tax_registered?\n self.provider_gst_number = provider.tax_number\n self.provider_gst = course.provider_fee*3/23\n self.provider_fee = self.provider_fee-self.provider_gst\n else\n self.provider_gst_number = nil\n self.provider_gst = 0\n end\n\n #adjust in case calc_cost is not course cost, should only happen if flat_fee\n difference = course.cost - calc_cost\n if difference != 0\n self.provider_fee = course.provider_fee + difference\n if provider.tax_registered?\n self.provider_gst_number = provider.tax_number\n self.provider_gst = course.provider_fee*3/23\n self.provider_fee = self.provider_fee-self.provider_gst\n else\n self.provider_gst_number = nil\n self.provider_gst = 0\n end\n end\n\n #adjust in case payment has been made already\n difference = cost - calc_cost\n if difference != 0\n #adjust processing_fee\n self.processing_fee = cost * course.provider_plan.processing_fee_percent\n self.processing_gst = self.processing_fee*3/23\n self.processing_fee = self.processing_fee-self.processing_gst\n\n #reset difference to adjust for processing_fee changes\n difference = cost - calc_cost\n\n #if payment exists then adjust provider fee to ensure the payment amount matches calc_cost\n adjustment_for_provider = difference\n adjustment_for_teacher = 0\n\n if provider_fee+provider_gst+difference < 0\n #if adjusted provider_fee is negative then deduct that negative amount from teacher_fee and make provider_fee 0\n adjustment_for_teacher = provider_fee+provider_gst+difference \n self.provider_fee = 0\n self.provider_gst = 0\n else\n self.provider_fee = provider_fee+provider_gst+adjustment_for_provider\n if provider.tax_registered?\n self.provider_gst = provider_fee*3/23\n self.provider_fee = provider_fee - provider_gst\n end\n end\n \n if adjustment_for_teacher != 0\n self.teacher_fee = teacher_fee+teacher_gst+adjustment_for_teacher\n if course.teacher.present? && course.teacher.tax_registered?\n self.teacher_gst = teacher_fee*3/23\n self.teacher_fee = teacher_fee-teacher_gst\n end\n end\n end\n end\n cost\n end",
"def bar_accepts_fee(fee)\n @bar_cash += fee\n end",
"def paycheck(hours_actually_editing, paycheck_total, hourly_charge = 50)\n\t(paycheck_total/hours_actually_editing) > hourly_charge\nend",
"def fiscal_years\n get_fiscal_years\n end",
"def profit_day_rate(cal)\n day_rate = avg_rate_card_amount_cents.round(2)\n mins_tracked = Timing.minute_duration_submitted_for_period_and_client(id, cal.start_date, cal.end_date)\n days_tracked = (hours = mins_tracked.to_s.to_d / account.account_setting.working_day_duration_minutes).round(2)\n invoiced_amount = Invoice.amount_cents_invoiced_for_period_and_client(id, cal.start_date, cal.end_date).round(2)\n total_project_potential = (days_tracked * avg_rate_card_amount_cents.round).round(2)\n\n if invoiced_amount == 0 && days_tracked != 0\n 0\n elsif invoiced_amount != 0 && days_tracked == 0\n invoiced_amount\n elsif invoiced_amount == 0\n day_rate\n else\n ((invoiced_amount / total_project_potential) * day_rate).round(2)\n end\n end",
"def fee\n\tparams['mc_fee']\n end",
"def change_active_fiscal_year\n return true if self.active\n if AppSetting.current_fiscal_year == self\n AppSetting.find_by_code(\"current_fiscal_year\").update_attributes(:value => FiscalYear.active_fiscal_years.first.year)\n end\n end",
"def safe_renewal_application_dates(status)\n case status\n when :draft, :enrollment_open\n current_effective_date (TimeKeeper.date_of_record + 2.months).beginning_of_month.prev_year\n when :enrollment_closed, :enrollment_eligible, :enrollment_extended\n current_effective_date (TimeKeeper.date_of_record + 1.months).beginning_of_month.prev_year\n when :active, :terminated, :termination_pending, :expired\n if TimeKeeper.date_of_record.month > 10\n current_effective_date (TimeKeeper.date_of_record - 3.months).beginning_of_month.prev_year\n elsif TimeKeeper.date_of_record.month == 1\n current_effective_date TimeKeeper.date_of_record.beginning_of_month.prev_year\n else\n current_effective_date (TimeKeeper.date_of_record - 1.months).beginning_of_month.prev_year\n end\n end\n end",
"def present_value\n # Payoff amount = 0, we’re assuming a fully amortizing loan\n payoff_amount = 0\n end",
"def fully_paid?\n amount_owed <= 0\n end",
"def daily_claim()\n if not @daily\n @daily = true\n @credits = @credits + 250\n val = \"Daily claimed!\"\n else\n val = \"You already claimed your daily!\"\n end\n val\n end",
"def paid_days_remaining\n days_elapsed = (Time.now.to_i - self.trial_started_at.to_i) / 60 / 60 / 24\n remaining = 365 - days_elapsed\n remaining = 0 if remaining < 0\n remaining\n end",
"def renewal_callback\n bill_id = params[:id].to_s\n bill_paid = params[:paid].to_bool\n bill_state = params[:state].to_s\n\n response = BillplzRenewal.check_status(bill_id)\n if (response['paid'] == true) && (bill_paid == true)\n @user = User.find_by(bill_id: params[:id])\n @year = @user.package\n @user.update_attribute(:status, 1)\n @user.update_attribute(:expiry, Time.now + @year.years)\n\n render json: { status: \"paid\" }, status: :ok\n else\n render json: { status: \"unpaid\" }, status: :ok\n end\n end",
"def update_fee\n\t\tmoney_info = money_info()\n\t\t@fee = money_info['Trade_Fee'] / 100.0\n\tend",
"def state_fulfillment_fee\n adjustments.eligible.where(:label => 'Additional State Fulfillment Fee').first.amount rescue 0.0\n end",
"def fee\n (amount * 0.005) if amount\n end",
"def fee\n params['mc_fee']\n end",
"def fee\n params['mc_fee']\n end",
"def pay_entry_fee(entry_fee)\n # if the guest has enough cash for entry_fee\n if @cash >= entry_fee\n # decrement guest cash by entry_fee\n @cash -= entry_fee\n # update guest entry_paid to true\n update_entry_paid()\n end\n end",
"def pre_claim?\n return false if filing_date.blank?\n\n filing_days_old = (Time.zone.today - filing_date).to_i.days\n\n # If the filing date is 365 days old or older then true (used for showing the claim)\n (filing_days_old <= Rails.configuration.x.returns.amendable_days)\n end",
"def pvcycle_total_fees\n pvcycle_membership_fee + pvcycle_contribution_fee\n end",
"def update_advance_fee_status\n if self.wallet_amount_applied\n student = Student.find_by_id(self.payee_id)\n advance_fee_wallet = student.advance_fee_wallet\n effective_amount = advance_fee_wallet.amount - self.wallet_amount\n if advance_fee_wallet.update_attributes(:amount => effective_amount)\n advance_fee_deduction = AdvanceFeeDeduction.new(:amount => self.wallet_amount,\n :deduction_date => Date.today,\n :student_id => student.id,\n :finance_transaction_id => self.id)\n # transaction_ledger = self.transaction_ledger\n # transaction_ledger.amount = self.amount.to_f\n # transaction_ledger.save\n if advance_fee_deduction.save\n return true\n else\n return false\n end\n end\n end\n end",
"def claim_amount_required?\n @full_repayment_of_ads != 'Y'\n end",
"def confirmation_period_expired?; end",
"def consignment_fee\n hash[\"ConsignmentFee\"]\n end",
"def yearly_rate\n\t\t yearly? ? rate : rate * 12\n\t\t end",
"def year1totalcharges\n @year1totalcharges = @year1total + @profit\n end",
"def disbursement_remaining_factor\n approved_amount == 0 ? 0 : 1 - (disbursed_amount / approved_amount.to_f)\n end",
"def free?\n self.setupFee == 0 && self.laborFee == 0 && self.oneTimeFee == 0 && self.recurringFee == 0 && self.hourlyRecurringFee == 0\n end",
"def fees(period = (Time.now.beginning_of_month - 1).beginning_of_month .. (Time.now.beginning_of_month - 1).end_of_month)\n subscription_payments.all(:conditions => { :created_at => period }).collect(&:affiliate_amount).sum \n end",
"def paid_thru_now\n # Turn off March 1 of year following paid year\n paid_thru_year >= (Date.today - 59).year\n end",
"def trading_fee\n return exchange_trading_fee if exchange_trading_fee > 0\n system_calculated_trading_fee\n end",
"def awaiting_financial_aid_approval?\n dean_approved? && !financial_aid_approved?\n end",
"def unpaid_amount\n gross_amount - paid_amount\n end",
"def profit\n \tself.bid - self.payout\n end",
"def allowed_to_pay_member_fee?\n return false if admin?\n\n if current_member? || in_grace_period?\n allowed_to_pay_renewal_member_fee?\n else\n allowed_to_pay_new_membership_fee?\n end\n end",
"def fees(period = (Time.now.beginning_of_month - 1).beginning_of_month .. (Time.now.beginning_of_month - 1).end_of_month)\n subscription_payments.where({ :created_at => period }).collect(&:affiliate_amount).sum\n end",
"def channel_fee\n 1\n end",
"def confirmation_period_valid?; end",
"def yearly_rate\n yearly? ? rate : rate * 12\n end",
"def disbursement_factor\n approved_amount == 0 ? 0 : disbursed_amount / approved_amount.to_f\n end",
"def total_non_insured_fees\n total_fee - total_insured_fees\n end",
"def tenure\n self.years_of_experience > 5 ? true : false\n end",
"def host_fee\n (total - net_rate).round(2)\n end",
"def old_enough_to_vote?(yr_born)\n (2016 - yr_born) >= 18 ? \"yes\" : \"no\"\nend",
"def send_outstanding_alert_to_approver(agency, user)\n setup_email\n body[:agency] = agency\n body[:user] = user\n recipients user.email\n subject \"Timesheet Approval Reminder\"\n end",
"def what_you_would_get_if_not_full\n if (qualifying_years + years_to_pension) < years_needed\n ((qualifying_years + years_to_pension).to_f / years_needed.to_f) * current_weekly_rate\n else\n current_weekly_rate\n end\n end",
"def billing_yearly?\n numbering_period == 'yearly'\n end",
"def paid?\n unless self.last_paid_at.blank?\n return Time.now - 365.days < self.last_paid_at\n else\n return false\n end\n end",
"def new_sale_price \n noi(num_years_to_hold + 1) / cap_rate(num_years_to_hold + 1)\n end",
"def profit\n total_before_tax - total_cost\n end",
"def profit\n total_before_tax - total_cost\n end",
"def free?\n\t\t\t\tnot(fee?)\n\t\t\tend",
"def eligibleRecu(annee = Date.today().year)\n Date.civil(annee, 1, 1).years_ago(16) <= self.naissance\n end",
"def update_yearly_rents_and_calculate\n unless @lbtt_return.flbt_type == 'CONVEY'\n # if the lease dates are nil then we don't need to calculate either\n return true if @lbtt_return.lease_start_date.nil? || @lbtt_return.lease_end_date.nil?\n\n # Stores the previous calculated years, which is the number of rows of the rental years if it's found,\n # otherwise it'll default to 0.\n # Normally, when the user has already entered the lease dates and then came back to change it, the old array\n # where the yearly_rents are stored will still be the same until when it gets changed later in this method.\n # So that's where the 'previous' comes from.\n previous = @lbtt_return.yearly_rents.nil? ? 0 : @lbtt_return.yearly_rents.length\n\n update_yearly_rents_array(previous)\n end\n setup_transaction_dates_step\n update_tax_calculations\n end",
"def tenure\n self.years_of_experience > 5\n end",
"def pay_all_bills\n #self.appointments.update_all(cost: 0)\n self.appointments.each {|a| a.paid}\n end",
"def total_unpaid_visits\n next_cutoff_date = Claim.order(date_paid: :desc).limit(1).pluck(:date_paid).first + 3.days rescue Date.today \n prev_cutoff_date = next_cutoff_date - 45.days \n @total_unpaid = Visit.where(status: BILLED).where(\"entry_ts > ?\", prev_cutoff_date).where(\"entry_ts <?\", next_cutoff_date).sum{|v| v.total_fee}\n flash[:info] = \"Current total of billed claims for all doctors for period ending #{next_cutoff_date} is: #{ sprintf \"$%.0f\", @total_unpaid}\"\n end",
"def dmail_inactive_approvers!\n days_until_next_month = (Date.current.next_month.beginning_of_month - Date.current).to_i\n return unless days_until_next_month <= 21\n\n inactive_approvers.each do |user|\n Dmail.create_automated(to: user, title: \"You will lose approval privileges soon\", body: <<~BODY)\n You've approved fewer than #{MINIMUM_APPROVALS} posts in the past\n #{APPROVAL_PERIOD.inspect}. You will lose your approval privileges in\n #{days_until_next_month} #{\"day\".pluralize(days_until_next_month)}\n unless you have approved at least #{MINIMUM_APPROVALS} posts by the end\n of the month.\n BODY\n end\n end",
"def current_payment_fee\n payment.try(:current_fee) || 0\n end",
"def coursefee\n course = Course.find(params[:id])\n @coursefee = course.total_fee.to_json\n return\n end",
"def can_pay_total?\n\n conf_payment_enabled = SystemConfiguration::Variable.get_value('booking.payment', 'false').to_bool\n conf_payment_total = (['total','deposit_and_total'].include?(SystemConfiguration::Variable.get_value('booking.payment_amount_setup', 'deposit')))\n\n if self.status == :pending_confirmation\n (conf_payment_enabled or force_allow_payment) and conf_payment_total and self.total_paid == 0 and ((!expired? and payment_cadence_allowed?) or force_allow_payment)\n elsif self.status == :confirmed # Confirmed in the back-office without payment\n (conf_payment_enabled or force_allow_payment) and conf_payment_total and self.total_paid == 0 and self.total_pending > 0\n else\n return false\n end\n\n end",
"def fee\n @ipn['mc_fee']\n end",
"def unpaid_amount\n draft ? nil : gross_amount - paid_amount\n end"
] | [
"0.7083792",
"0.66952085",
"0.63984054",
"0.61315197",
"0.6065965",
"0.59469116",
"0.58892107",
"0.58567846",
"0.5822668",
"0.5762425",
"0.5701278",
"0.5681439",
"0.5674794",
"0.56666344",
"0.5627841",
"0.56168014",
"0.5615803",
"0.5609673",
"0.5608684",
"0.55949587",
"0.5587023",
"0.5549833",
"0.553857",
"0.5525805",
"0.55250776",
"0.5518585",
"0.5512718",
"0.5504001",
"0.5474227",
"0.5472886",
"0.5453857",
"0.5451706",
"0.5451706",
"0.5432004",
"0.54304194",
"0.5430402",
"0.54258764",
"0.5421941",
"0.54177403",
"0.5417719",
"0.5417114",
"0.54095715",
"0.5405933",
"0.53840786",
"0.5381622",
"0.53721154",
"0.53716147",
"0.53576094",
"0.5357304",
"0.53343",
"0.53302854",
"0.53277457",
"0.5325689",
"0.53206617",
"0.53206617",
"0.53148186",
"0.5308657",
"0.5300472",
"0.5300353",
"0.5299067",
"0.52966523",
"0.5293143",
"0.5282377",
"0.52823204",
"0.5276741",
"0.52698696",
"0.5269418",
"0.52624613",
"0.5258612",
"0.5257211",
"0.5249287",
"0.5232439",
"0.52322334",
"0.52283907",
"0.52227825",
"0.5220923",
"0.52149576",
"0.52142495",
"0.52117306",
"0.52109456",
"0.5209152",
"0.5208257",
"0.519915",
"0.519354",
"0.51928294",
"0.5187438",
"0.5185401",
"0.51844406",
"0.51844406",
"0.5182889",
"0.5178732",
"0.5175672",
"0.5174912",
"0.5173718",
"0.5173235",
"0.5171752",
"0.5169252",
"0.515925",
"0.5157343",
"0.5156112",
"0.5156017"
] | 0.0 | -1 |
add_item accepts a title and a price and increases the total also accepts an optional quantity doesn't forget about the previous total | def add_item (title, price, quantity=1)
self.total += price * quantity
quantity.times do
@items << title
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_item(title, price, quantity=1)\n #and increases the total\n self.total += price * quantity\n #times.do for all the items\n quantity.times do\n @items << title\n end\n #doesn't forget about the previous total\n self.last_transaction = price * quantity\n end",
"def add_item(title, price, quantity=1) \n self.total += price * quantity\n quantity.times do\n items << title \n end\n self.last_transaction = price * quantity\n\n end",
"def add_item(title, price, quantity = 1)\n @title = title\n @price = price\n quantity.times {@items << title}\n @last_transaction = @price * quantity\n @total = @total + (@price * quantity)\n @total\n end",
"def add_item (title, price, quantity = 1)\n i = 0\n while i < quantity\n @items << title\n i += 1\n end\n my_price = price * quantity\n @transactions << my_price\n @total += (price * quantity)\n end",
"def add_item(title, price, quantity =1)\t#increases the total\n\t\tcounter = quantity\n\n\t\twhile counter > 0\n\t\t\t@@all << title\n\t\t\tcounter -= 1\n\t\tend\n\n\t\t\n\t\t@prev_total = @total\n\t\t\n\t\t@total = (@prev_total + (price * quantity))\n\n\n\t\t@total \t\t\t\n\tend",
"def add_item(title, p, q=1) # accepts a title and a price AND inc. the total. Optional quantity set to 1 since u will always have at least one item.\n @total += (p*q) # @ total is price times quantity, and increments (does not forget previous total as u add new items)\n q.times do # want to add the item as many times to the list as its quantity so keep doing this the # of times its quantity is\n @items << title\n end\n @last_transaction = p # the last transaction = the price of the last item added\n end",
"def add_item(title, price, quantity=1)\n self.total += price * quantity\n #quantity amount of times it'll add the title to the items array\n quantity.times {items << title}\n self.last_transaction = price * quantity\n end",
"def add_item(title, price, quantity = 1)\n @total += price*quantity\n @instance_items << [title, price, quantity]\nend",
"def add_item(title, price, quantity=1)\n self.total += price * quantity #Think about this logically\n #you go into a store and buy and item. How do you get the total of the item.\n #you MULTIPLY BY THE PRICE!!!! DURRRRR!!! GOD MORTY YOUR SO DUMB\n @price = price\n #do this x amount of times.\n quantity.times do\n @items << title\n end\n\n end",
"def add_item(title, amount, quantity=1)\n self.total += amount * quantity\n quantity.times do\n items << title\n end\n self.last_transaction = amount * quantity\n end",
"def add_item(item, price, quantity=1)\n @total += (price * quantity)\n @items.fill(item, @items.size, quantity)\n @last_transaction = {item => (price * quantity)}\n @last_qty = quantity\n end",
"def add_item(name, price, quantity = 1)\n self.total += price * quantity\n quantity.times {self.items << name}\n record_trans(name, price, quantity)\n end",
"def add_item (title, price, quantity = 1)\n # adds purchase price to total\n @total += price * quantity\n # Adds proper quanity of item to cart\n count = 0\n while count < quantity\n @items << title\n count += 1\n end\n # keeps track of last_added item\n @last_transaction[:item] = title\n @last_transaction[:price] = price\n @last_transaction[:quantity] = quantity\n\n end",
"def add_item(item, price, quantity = 1)\n self.total += price * quantity\n self.last_item = price\n self.last_quantity = quantity\n\n counter = 0\n while counter < quantity\n self.cart << item\n counter += 1\n end\n self.cart\n end",
"def add_item(item, price, *quantity)\n q = quantity.join(\"\").to_i\n if q > 1\n q.times do\n @items.push(item)\n end\n else\n @items.push(item)\n end\n if q > 1\n price_with_quantity = q * price\n @last = price_with_quantity\n @total += price_with_quantity\n else\n @last = price\n @total += price\n end\n\n end",
"def add_item(item, price, quantity = 1)\n @total += price * quantity\n @transactions << price * quantity\n i = quantity\n until i == 0 do\n @items << item\n i -= 1\n end\n end",
"def add_item(item_name, price, quantity = 1)\n @transactions << Transaction.new(item_name, price, quantity)\n quantity.times{self.items << item_name}\n self.total += price*quantity\n end",
"def add_item(item, price, quantity=1)\n # to call an instance method inside another instance method, use the self keyword to refer to the instance on which you are operating\n self.total += price * quantity # increment the total by the result of (price X quantity)\n # puts \"total: #{self.total}\"\n\n quantity.times do\n @items << item # add item to array 'quantity' # of times ***see note below\n end\n\n @last_transaction = price * quantity # keep track of the last transaction amount added\n # puts \"last transaction: #{@last_transaction}\"\n end",
"def add_item(string, float, integer = 1)\n # adds item price to total\n @total += float * integer\n # accepts an optional quantity of the item\n quantity = integer\n # loops to add item multiple times to the list \n quantity.times {@items << string}\n # holds the amount of the last transaction\n self.last_transaction = float * quantity\n end",
"def add_item(item, amount, quantity = 1)\n\n if quantity > 1\n self.total += (amount * quantity)\n quantity.times do \n @items << item\n end\n else\n self.total += amount\n @items << item\n end\n @last_amount = amount * quantity\n end",
"def add_item(title, price, quantity = 1)\n item = {\n title: title,\n price: price,\n quantity: quantity\n}\n\n\n@items_array << item\n@total += price * quantity\n\n\nend",
"def add_item(item, quantity = 1)\n order_item = self.order_items.find_by item: item, price: item.price\n if order_item.is_a? OrderItem\n order_item.add quantity\n else\n self.order_items.create item: item, price: item.price, quantity: quantity\n end\n recalculate!\n end",
"def add\n @item.increment(:quantity)\n @item.save!\n\n refresh\n end",
"def add_item(item, qty)\n for ele in @order do\n order_item = ele.keys[0]\n if order_item.name == item.name\n ele[order_item] += qty\n return \n end\n end\n @order.push({item => qty})\n \n end",
"def purchase(item_price)\n @total += item_price\n total\n end",
"def add_item\n\t puts \"What is the name of the item you'd like to add?\"\n\t\t@item_name = gets.chomp\n\t\tputs \"And how many?\"\n\t\t@quantity = gets.chomp.to_i\n\t\tif @quantity <= 0\n\t\t puts \"Please enter a number higher than 0.\"\n\t\t puts \"(Also, must be '1' not 'one'.)\"\n\t\telse\n\t\t @grocery_list[@item_name] = @quantity\n\t\tend\n\t\tget_item\n\tend",
"def add_item(item, quantity=1, hash)\n# get item name and quantity\n# if there's no quantity, set it to 1\n\thash[item] = quantity\n\t# output: return the hash with updated key/value pairs\n\thash\nend",
"def add_item(hash_of_items, item, quantity=1)\n hash_of_items[item] = quantity\n hash_of_items\nend",
"def add_item(item, quant=0)\n\t$grocery_list.store(item, quant)\n\tp \"You added #{item} to your list.\"\nend",
"def add_item(list, item_name, qty=1)\n if list.has_key?(item_name)\n list[item_name] += qty\n else\n list[item_name] = qty\n end\n list\nend",
"def update_quantity(item, list, quantity)\n add_item(item, list, quantity)\nend",
"def add_item(item_list, item, qty)\r\n item_list[item] = qty\r\n item_list\r\nend",
"def update_qty(shopping_list, item, quantity)\r\n\r\n\tadd_item(shopping_list, item, quantity)\r\n\r\nend",
"def add_item(order_id, item_sku, price, quantity, name = nil, category = nil, utmhid = random_id)\n check_account_params\n hey(item_params(order_id, item_sku, name, category, price, quantity, utmhid))\n end",
"def add_item\n\t\tset_sale\n\t\tpopulate_products\n\n\t\tline_item = Item.where(sale_id: params[:sale_id], product_id: params[:product_id]).first\n\t\tline_item.quantity += 1\n\t\tline_item.save\n\n\t\t# Llama método que reduce cantidad de stock\n\t\tremove_item_from_stock(params[:product_id])\n\t\tupdate_line_item_totals(line_item)\n\n\t\tupdate_totals\n\n\t\trespond_to do |format|\n\t\t\tformat.js { ajax_refresh }\n\t\tend\n\tend",
"def add_item(product_id:, quantity: 1)\n product = Product.find(product_id)\n\n order_item = order.items.find_or_create_by(\n product_id: product_id\n )\n\n order_item.price = product.price\n order_item.quantity = 1\n order_item.save\n end",
"def add_item (grocery, item_name, quantity)\n grocery[item_name] = quantity\n display_list(grocery)\n end",
"def add_to_order(add_qty=0)\n \t@quantity += add_qty\n end",
"def add_to_cart(product, amount)\n purchase = \" • #{amount} #{product}\\n\"\n @cart << purchase\n\n cost_per_item = @inventory[product][\"price\"]\n @total_cart_value += (cost_per_item * amount)\n\n @inventory[product][\"quantity\"] -= amount\nend",
"def add_item(list_items, item_name, item_qty)\n if list_items.include?(item_name)\n list_items[item_name] += item_qty\n else\n list_items[item_name] = item_qty\n end\nend",
"def add_item(item, quantity, list)\n\tlist[item] = quantity\n\titem\nend",
"def add_item (item, optional_quantity = 0)\n item_hash[item] = optional_quantity\nend",
"def add(item)\n self.items.push(item)\n if self.min_price > item.price.to_i\n self.min_price = item.price.to_i\n end\n self.owners.push(item.owner)\n self.owners = self.owners.uniq\n self.quantity += item.quantity\n self\n end",
"def add_item(list, item_name, quantity = 1)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add_item(list, item_name, quantity = 1)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add_item(list, item_name, quantity = 1)\n\tlist[item_name] = quantity\n\tlist\nend",
"def update_quantity(grocery_list, item, quantity)\r\n add_item(grocery_list, item, quantity)\r\n \r\nend",
"def add_item(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add_item(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add\n quantity = params[:quantity].try(:to_i) || 1\n if !add_item?(params[:id], quantity)\n flash[:warning] = 'Invalid input'\n end\n redirect_to cart_index_path\n end",
"def add(list, item, quantity)\r\n# input: item name and optional quantity\r\nlist.include?(item) ? list[item] += quantity : list[item] = quantity\r\np list\r\nend",
"def add_item(product_id, quantity)\n product = Product.find(product_id) # product is exists?\n\n quantity = quantity.blank? ? 1 : (quantity.to_i > 99? 99 : quantity.to_i)\n\n return if quantity < 1 # return if invalid quantity is provided\n \n if cart_item = @items.find { |item| item.id.to_i == product_id.to_i }\n cart_item.quantity += quantity\n cart_item.quantity < 99 ? cart_item.quantity : cart_item.quantity =99\n else\n @items << CartItem.new(product.id, quantity)\n end\n\n end",
"def add_item(grocery_list, item_name, qty = 1)\r\n\tgrocery_list[item_name] = qty\r\n\treturn grocery_list\r\nend",
"def add_item(hash, item, qty)\n\n if hash.has_key?(item)\n hash[ item ] += qty\n else\n hash[ item ] = qty\n end\n\nend",
"def add_item(list, item_name, quantity = 1)\n if list.include?(item_name)\n list[item_name] += quantity\n else\n list[item_name] = quantity\n end\n list\nend",
"def add_item(list, item, quantity = 1)\r\n# input: list, item name, and optional quantity\r\n# steps: \r\n # check for optional quantity. if not present, set to default (1)\r\n list[item] = quantity\r\n # update list with input\r\n puts \"#{item.upcase} has been added to your grocery list!\"\r\n p list\r\n# output: complete list, updated\r\nend",
"def add(list, item_name, quantity)\n\tlist[item_name] = quantity\n\tlist\nend",
"def add(selected_item, count = 1)\n item = find_item(selected_item)\n if item != nil\n init_count = item.fetch(\"count\").to_i\n init_count += count.to_i\n item.store(\"count\", init_count)\n else\n struct = CartItem.new\n struct.cart_item_id = selected_item.id\n struct.count = count.to_i\n @items.push(struct)\n end\n end",
"def add(quant)\n\t\tself.quantity += quant\n\tend",
"def add_product(product, quantity=1, payment_method='deposit')\n item = @items.find { |i| i.product_id == product.id && i.payment_method == payment_method }\n if item\n item.quantity += quantity\n if item.quantity > 20\n item.quantity = 20\n @quantity_error=\"Only 20 Items may be added at one time. If you need to purchase additional items please contact customer service.\"\n end\n else\n @items << OrderLineItem.new(\n :product_id => product.id,\n :quantity => quantity,\n :unit_deposit => product.deposit,\n :unit_price => product.price,\n :payment_method => payment_method\n )\n end\n end",
"def add_item(list, add_item, add_quantity=1)\n# steps:\n # Add item as key and quantity as value to final_list hash(item and quantity will be user inputs)\n list[add_item] = add_quantity\n # Return updated hash\n list\nend",
"def add_item(inventory, item, quantity)\n\tinventory[item] = quantity\n\t@full_inventory = inventory\n\t#this is what updates your inventory with the new item & quantity.\nend",
"def add_item(list, item_to_be_added, qty = 1)\n # if !list.has_key? item_to_be_added\n # list[item_to_be_added] = qty\n # end\n list[item_to_be_added] = qty if !list.has_key? item_to_be_added\n list\nend",
"def add_item(list, new_item, qty=1)\n list[new_item] = qty\nend",
"def add\n\t\tadd_to_cart(params[:item_obj], params[:qty])\n flash[:notice] = \"Succesfully added to your cart!\"\n\t\tredirect_to :controller => \"items\", :action => \"show\"\n\tend",
"def add_item(list, item, qty=1)\n list[item] = qty\n p \"#{item} : #{list[item]}\"\nend",
"def add_item(shopping_list, item, quantity)\r\n\tshopping_list[item] = quantity\r\n\tshopping_list\r\nend",
"def add_item\n prod_id = params[:product_id].to_s\n unless Product.find(prod_id).nil?\n item = cart[prod_id] || {\"Num\" => 0}\n item[\"Num\"] += 1\n cart[prod_id] = item\n update_cart cart\n flash[:success] = t('itm_added')\n redirect_back fallback_location: :root\n end\n end",
"def add_item(d_item, name=nil)\n item = d_item.item\n if !name then name = item.name end\n #if we already have an item in this box\n if @d_item\n #if same item or\n if (item.id == @d_item.item.id) && (item.quality == @d_item.item.quality)\n max = @d_item.max?\n total = @d_item.item.quantity+item.quantity\n if total > max\n @d_item.item.quantity = max\n item.quantity = (total - max)\n @d_item.refresh\n return 2\n else\n @d_item.item.quantity += item.quantity\n @d_item.refresh\n return 1\n end\n end\n #if different item or quality, cannot merge\n return 2\n end\n #if empty, add the item\n @d_item, @last_item = d_item, item.clone\n @d_item.refresh\n return 3\n end",
"def add_item(grocery_list, item_name, qty = 1)\n\tgrocery_list[item_name] = qty\n\treturn grocery_list\nend",
"def additem(list, item, number = 1)\n# input: hash, item name and optional quantity\n# steps: push an item into the hash\n list.store(item, number)\nend",
"def add_item(list,item_name, qty)\n list[item_name] = qty\nend",
"def add_item(grocery_list,item,quantity = nil)\n \tif quantity == nil \n \tgrocery_list[item] = 1\n else\n grocery_list[item] = quantity\n end\n return grocery_list\nend",
"def add_item(item_name, grocery_list, quantity=1)\n grocery_list[item_name] = quantity\n grocery_list\n end",
"def update(list, item, qty)\n add_item(list, item, qty)\nend",
"def add_items(list, item_name, quantity=0)\r\n\tlist[item_name] = quantity\r\n\tlist\r\nend",
"def add_item(list, item_name, quantity=1)\n list[item_name] = quantity\nend",
"def add_item(item,amount=1,the_lists)\r\n\t# steps: accept 2 arguments. Item name and Quantity (with default)\r\n\tif the_lists[item] != nil\r\n\t puts \"Item is already on the List !\"\r\n\t puts \"Added amount to the quantity\"\r\n\t the_lists[item] += amount\r\n\telse\r\n the_lists[item] = amount\r\n\tend\r\n\r\n\tprint_list(the_lists)\r\nend",
"def add_item(shopping_list, item, quantity=1)\r\n\r\n\tshopping_list[item] = quantity\r\n#\treturn shopping_list\r\nend",
"def add_item(list_name, item_name, quantity = 1)\r\n if list_name.has_key?(item_name)\r\n list_name[item_name] += quantity\r\n else\r\n list_name[item_name] = quantity\r\n end\r\nend",
"def add_an_item(grocery_list, new_item, qty = 1)\n grocery_list[new_item] = qty\n grocery_list\nend",
"def add_item(item_id)\n if line_item = line_items.find_by(item_id: item_id)\n line_item.quantity += 1\n else\n line_item = line_items.build(item_id: item_id)\n end\n line_item\n end",
"def add_item(item,quantity,first_list)\n if quantity == \"\"\n quantity = 1\n else\n quantity\n end\n first_list[item] = quantity\n\nend",
"def add_item(product_id)\n item = line_items.where(product_id: product_id).first\n if item.present?\n item.quantity += 1\n item\n else\n line_items.new(product_id: product_id)\n end\n end",
"def add_item(current_list, item_added, quantity)\n current_list[item_added] = quantity\n current_list\nend",
"def add_item(item_id)\n line_item = self.line_items.find_by(item_id: item_id)\n if line_item\n line_item.quantity += 1\n else\n line_item=self.line_items.build(item_id: item_id)\n end\n line_item\n end",
"def add_item(new_list, item_name, quantity=1)\r\n \r\n new_list[item_name] = quantity\r\n \r\nend",
"def add_item(grocery,item_name,quantity)\n # input: list, item name, and optional quantity\n # steps: insert item_name as a key and quantity as a value to the hash \n grocery[item_name] = quantity\n # output:display the latest list\n display_list(grocery)\nend",
"def add_item(olist, item, quant=1)\n new_list = {item => quant}\n olist.merge(new_list)\nend",
"def add_items(grocery_list, item, quantity)\n if grocery_list.include? item\n grocery_list[item] += quantity\n else\n grocery_list[item] = quantity\n end\n grocery_list\nend",
"def add_items(grocery_list, item, quantity)\n if grocery_list.include? item\n grocery_list[item] += quantity\n else\n grocery_list[item] = quantity\n end\n grocery_list\nend",
"def adding_item(list,item,quantity = 1)\r\n# if quantity == nil\r\n# quantity = 1\r\n# end\r\n list[item] = quantity\r\n list\r\nend",
"def add_item(list, item, quantity=1)\r\n# input: item name and optional quantity\r\n# steps: \r\n # Use shopping list as input\r\n # Use the item to be added as 2nd input\r\n # Use the item quantity as a 3rd input (look up whether optional input is possible)\r\n # Add the item and quantity to the shopping list\r\n list[item] = quantity\r\n# output: shopping list with the added item and quantity\r\n printlist(list)\r\nend",
"def add_item(list, item, quantity=0)\n\tlist[item] = quantity\n\tlist\nend",
"def add_new_items(list, item_name, quantity=1)\n list[item_name] = quantity\n list\nend",
"def add(input_list, item, quantity)\n input_list[item] = quantity\nend",
"def add_item(grocery_list, item, quantity = 1)\n \tgrocery_list[item.to_sym] = quantity\nend",
"def add_item(grocery_list, item, quantity=1)\n grocery_list[item] = quantity\n grocery_list\nend",
"def add_or_update_item_qty(shopping_list, item, quantity)\n shopping_list[item] = quantity\nend",
"def add_item(grocery_list, item, qty)\n grocery_list[item] = qty \n grocery_list\nend"
] | [
"0.88109183",
"0.87535137",
"0.86145264",
"0.8517917",
"0.85166854",
"0.8487527",
"0.8483714",
"0.8397211",
"0.8358682",
"0.8340887",
"0.825319",
"0.8236478",
"0.82202965",
"0.81615055",
"0.8109122",
"0.81018835",
"0.80452096",
"0.78962755",
"0.7825504",
"0.7732733",
"0.7684683",
"0.7670786",
"0.74485826",
"0.74295104",
"0.74181914",
"0.74074113",
"0.7351377",
"0.73474586",
"0.7319629",
"0.73178416",
"0.7309311",
"0.7293191",
"0.72620153",
"0.7242302",
"0.72388995",
"0.7219301",
"0.7191846",
"0.7166319",
"0.7144882",
"0.7142448",
"0.71342707",
"0.7102509",
"0.7101701",
"0.7096515",
"0.7096515",
"0.7095006",
"0.7081078",
"0.70742476",
"0.70742476",
"0.70738393",
"0.70604813",
"0.7053778",
"0.7018166",
"0.70178384",
"0.7017004",
"0.7013221",
"0.70060176",
"0.69998705",
"0.69910204",
"0.6985673",
"0.6977396",
"0.69664794",
"0.69610685",
"0.6960773",
"0.6954786",
"0.695266",
"0.6952577",
"0.6951742",
"0.6950728",
"0.69455814",
"0.69449407",
"0.6942872",
"0.6942741",
"0.6942522",
"0.6940202",
"0.6938886",
"0.6934624",
"0.69343287",
"0.69310224",
"0.6924741",
"0.692402",
"0.69197536",
"0.6917082",
"0.6912084",
"0.6907742",
"0.6907116",
"0.69009894",
"0.6891918",
"0.6891315",
"0.68902904",
"0.68902904",
"0.68883884",
"0.6885371",
"0.6881726",
"0.6881201",
"0.686426",
"0.68602675",
"0.68588436",
"0.6858117",
"0.6852495"
] | 0.8702204 | 2 |
items returns an array containing all items that have been added apply_discount the cash register was initialized with an employee discount applies the discount to the total price returns success message with updated total reduces the total the cash register was not initialized with an employee discount returns a string error message that there is no discount to apply | def apply_discount
if discount !=0
self.total = total- (total*(discount/100.to_f)).to_i
"After the discount, the total comes to $#{self.total}."
else
"There is no discount to apply."
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_discount(items)\n 0\n end",
"def test_discount_on_item_not_valid_for_discount\n # Add 3 green tea to line items\n line_items = [ @green_tea_in_cart_1, @green_tea_in_cart_2, @green_tea_in_cart_3]\n @bulk_discount.apply(line_items)\n\n # Test if the discount is applied\n assert_equal @green_tea_in_cart_1.price, @green_tea.price, \"Discount not applied\"\n assert_equal @green_tea_in_cart_2.price, @green_tea.price, \"Discount not applied\"\n assert_equal @green_tea_in_cart_3.price, @green_tea.price, \"Discount not applied\"\n end",
"def test_discount_on_bulk_quantity_of_item\n # Add 3 strawberries to line items\n line_items = [ @strawberry_in_cart_1, @strawberry_in_cart_2, @strawberry_in_cart_3]\n @bulk_discount.apply(line_items)\n\n # Test if the discount is applied\n assert_equal @strawberry_in_cart_1.price, @strawberry.price - @bulk_discount.bulk_discount, \"Discount applied\"\n assert_equal @strawberry_in_cart_2.price, @strawberry.price - @bulk_discount.bulk_discount, \"Discount applied\"\n assert_equal @strawberry_in_cart_3.price, @strawberry.price - @bulk_discount.bulk_discount, \"Discount applied\"\n end",
"def applyDiscount\n # get all rules with an item code\n rules = @rules.select { |obj| obj.getCode != \"total\" } \n rules.each do |rule|\n # find the minimum threshold for the rule to apply\n size = @items.select { |item| item.getCode == rule.getCode }.size \n # if threshold is not exceeded\n unless rule.getThreshold > size \n @items.each do |item| \n # if item code matches the rule code\n if(item.getCode == rule.getCode) \n # reset the price to the initial price to revert modifications\n item.refreshPrice \n # compute discount price based on rule\n item.setPrice(rule.getPercent ? item.getPrice * (1-rule.getValue) : item.getPrice - rule.getValue) \n end\n end\n end\n end\n end",
"def checkout(cart, coupons)\n #call the consolidate to get the count item first\n hash_cart = consolidate_cart(cart)\n #apply coupon to the new cart\n applied_coupons= apply_coupons(hash_cart, coupons)\n #apply clearance after discount from coupon\n applied_discount= apply_clearance(applied_coupons)\n\ntotal = applied_discount.reduce(0){ |acc,(key, value)| acc+= value[:price]*value[:count]}\n total >= 100 ? total * 0.9 : total\n end",
"def apply_discount\n\n #Check if discount is applicable. Purchases is a hash with the stock item as\n # a key. disc_items is the list of items that have to be bought together\n # if the discount is to be applicable. For each of these the code checks to\n # see if the item is in the carts purcheses hash. If after this process\n # apply is still true then the relevant discount has to applied to each of the \n # purchases in the current discount list. \n apply = true\n \n @cart_disc_list.each { |d| d.disc_items.each {|v| \n \n\t apply = (apply && @purchases.has_key?(v)) \n }\n \n if (apply == true)\n # apply discount\n\n\t d.disc_items.each { |w| \n @purchases[w].discount = d.percentage_discount\n @purchases[w].adjusted_price -= \n (@purchases[w].price * @purchases[w].discount / 100 ) \n \t\t\t }\n\t end\n apply = true\n }\n end",
"def test_discount_on_less_quantity_of_item\n # Add 2 strawberries to line items\n line_items = [ @strawberry_in_cart_1, @strawberry_in_cart_2]\n @bulk_discount.apply(line_items)\n\n # Test if the discount is applied\n assert_equal @strawberry_in_cart_1.price, @strawberry.price, \"Discount not applied\"\n assert_equal @strawberry_in_cart_2.price, @strawberry.price, \"Discount not applied\"\n end",
"def computeTotal\n # get rule for total\n rule = @rules.find{ |obj| obj.getCode == \"total\" } \n # sum item prices\n total = @items.inject(0){|sum, x| sum + x.getPrice} \n # if rule exists and condition is met, apply discount\n if rule && total > rule.getThreshold \n total = rule.getPercent ? total * (1-rule.getValue) : total - rule.getValue\n end\n return total\n end",
"def calculate_total\n\t\t@total_items.each do |element|\n\t\t\tif element.class==Apples\n\t\t\t\t@apple_count=@apple_count+1\n\t\t\t\tif @apple_count==2\n\t\t\t\t\t@apple_count=0\n\t\t\t\t\t@apple_discounts = @apple_discounts+1\n\t\t\t\telse\n\t\t\t\t\t@total = @total + element.price\n\t\t\t\tend\n\n\t\t\telsif ((@today.wday==6 || @today.wday==0) && element.class==Watermelons)\n\t\t\t\t@total = @total + (element.price*0.9) #10% on watermelons on weekends\n\t\t\t\t@weekendWatermelon = true\n\t\t\t\t\n\t\t\telse\n\t\t\t@total = @total + element.price\n\t\t\tend\n\n\n\t\tend\n\n\t\t#Checks for Weekend Watermelon discount applied\n\t\tif @weekendWatermelon\n\t\t\tputs \"10% discount on Watermelons on weekends!\"\n\t\tend\n\n\t\t#Count number of 2x1's applied\n\t\tif (discountApple)>0\n\t\t\tputs \"Congratulations! You received #{@apple_discounts} 2x1's on apples and saved #{@apple_discounts*10} euros!\"\n\t\tend\n\t\t#Check for 10 euro discount\n\t\tif (discount100(@total))\n\t\t\t@total = @total-10\n\t\t\tputs \"Congratulations! You received a 10 euro discount for buying more than 100 euros worth of fruit!\"\n\t\tend\n\n\t\t#Check for 5% discount\n\t\tif (discount5)\n\t\t\t@total = @total*0.95\n\t\t\tputs \"Congratulations! You received a 5% discount for buying more than 5 items!\"\n\t\tend\n\t\treturn @total\n\tend",
"def apply(product, items_bought)\n times_discount_applied = items_bought / @discount_for_every\n percent = BigDecimal((@percent/100.to_f).to_s)\n discounted_items = (times_discount_applied * @discount_for_every).to_s.to_d\n percent * discounted_items * product.price\n end",
"def apply_coupons(cart, coupons)\n coupons.each do |cpn|\n #set variable equal to the name of the discounted item for cleaner code\n discounted_item = cpn[:item]\n #if the item exists in the cart...\n if cart[discounted_item] != nil\n #if the cart has the minimum count of items for a coupon to be valid...\n if cart[discounted_item][:count] >= cpn[:num]\n #calculate the discounted price for the item\n new_price = cpn[:cost] / cpn[:num]\n #calculate the number of items remaining at full price\n remaining_full_price = cart[discounted_item][:count] % cpn[:num] #3%2 = 1\n #calculate the number of items that will have the discounted price applied\n coupon_applied = cart[discounted_item][:count] - remaining_full_price\n #maintain the clearance status\n clearance = cart[discounted_item][:clearance]\n #create new discounted item\n cart[\"#{discounted_item} W/COUPON\"] = {:price => new_price, :clearance => clearance, :count => coupon_applied}\n #change the previous cart number to the number remaining\n cart[discounted_item][:count] = remaining_full_price\n #else, the cart doesn't have the minimum number of items required to qualify for the coupon\n #OR the item doesn't exist in the cart\n else\n #donothing\n end\n end\n end\n cart\nend",
"def calculate_item_amount_with_discount(item, user)\n\n item_bill_amount = calculate_item_amount(item.quantity, item.price)\n return item_bill_amount if item.is_grocery? \n\n\n return item_bill_amount - (item_bill_amount * get_discount_percentage(user))/100\n end",
"def apply_coupons(cart, coupons)\n coupons.each do |coupon|#for each coupon...\n coupon_item = coupons[coupon][:item]\n if cart[coupon_item][:count] >= coupons[coupon][:num] #if there are at least enough items for the coupon to be applied...\n new_price = coupons[coupon][:cost] / coupons[coupon][:num] #calculate the discounted price for the item\n remaining_full_price = cart[coupon_item][:count] % coupons[coupon][:num] #calculate the number of items remaining at full price\n coupon_applied = cart[coupon_item][:count] - remaining_full_price #calculate the number of items that will have the discounted price applied\n cart[\"#{coupon_item} W/COUPON\"] = {:price => new_price, :clearance => true, :count => coupon_applied} #create new discounted item\n cart[coupon_item][:count] = remaining_full_price #change the previous cart number to the number remaining\n if cart[coupon_item][:count] == 0 #if there are no full price items left...\n cart.delete(coupon_item) #delete the full price item hash from the cart\n end\n else\n false\n end\n end\n cart #return the new cart with coupons applied\nend",
"def si_item_totals\n qty = params[:qty].to_f / 10000\n amount = params[:amount].to_f / 10000\n tax = params[:tax].to_f / 10000\n discount_p = params[:discount_p].to_f / 100\n withholding = params[:withholding].to_f / 10000\n # Bonus\n discount = discount_p != 0 ? amount * (discount_p / 100) : 0\n # Taxable\n taxable = amount - discount\n # Taxes\n tax = tax - (tax * (discount_p / 100)) if discount_p != 0\n # Total\n total = taxable + tax + withholding\n # Format output values\n qty = number_with_precision(qty.round(4), precision: 4)\n amount = number_with_precision(amount.round(4), precision: 4)\n tax = number_with_precision(tax.round(4), precision: 4)\n discount = number_with_precision(discount.round(4), precision: 4)\n taxable = number_with_precision(taxable.round(4), precision: 4)\n total = number_with_precision(total.round(4), precision: 4)\n # Setup JSON hash\n @json_data = { \"qty\" => qty.to_s, \"amount\" => amount.to_s, \"tax\" => tax.to_s,\n \"discount\" => discount.to_s, \"taxable\" => taxable.to_s, \"total\" => total.to_s }\n render json: @json_data\n end",
"def scan(items)\n items = Array(items)\n\n # Prune any items we don't have rules for \n items = self.filter_bad_items items \n\n if items.count > 0\n items.each do |item|\n # Add the item to the checkout's current_items instance var\n @current_items << item \n \n puts \"+ Added item #{item.name} to the checkout.\"\n\n # We then update the total of the checkout to keep everything up to date\n self.update_total\n end \n else\n # Output nil scan to user\n puts \"- No valid items provided, skipping scan...\"\n end\n end",
"def calculate_product_total(items_bought)\n result = items_bought * @price\n if @discount\n result -= @discount.apply(self, items_bought)\n end\n result \n end",
"def apply_coupons(cart, coupons)\n coupon_item = coupon[:item]\n if cart[coupon_item][:count] >= coupons[coupon][:num] #if there are at least enough items for the coupon to be applied...\n new_price = coupons[coupon][:cost] / coupons[coupon][:num] #calculate the discounted price for the item\n remaining_full_price = cart[coupon_item][:count] % coupons[coupon][:num] #calculate the number of items remaining at full price\n coupon_applied = cart[coupon_item][:count] - remaining_full_price #calculate the number of items that will have the discounted price applied\n cart[\"#{coupon_item} W/COUPON\"] = {:price => new_price, :clearance => true, :count => coupon_applied} #create new discounted item\n cart[coupon_item][:count] = remaining_full_price #change the previous cart number to the number remaining\n if cart[coupon_item][:count] == 0 #if there are no full price items left...\n cart.delete(coupon_item) #delete the full price item hash from the cart\n end\n else\n false\n end\n cart #return the new cart with coupons applied\nend",
"def total_discounts\n ipod = @items.index { |x| x.product.name == 'iPod' && x.quantity >= 2 }\n imac = @items.index { |x| x.product.name == 'iMac' }\n if ipod && imac\n # discount applies\n iphone = @items.index { |x| x.product.name == 'iPhone 4' }\n total_discount = @items[iphone].quantity * (@items[iphone].product.price - @items[iphone].product.discounted) if iphone \n end\n total_discount ||= 0\n end",
"def calculate_net_amount\n @items.each do |item|\n item.price_after_discount = @discount_processor.calculate_item_amount_with_discount(item, @user)\n end\n\n #total items bill amount\n items_total = @items.map(&:price_after_discount).reduce(:+)\n\n #applying discount on total amount.\n @discount_processor.apply_discount_on_total(items_total)\n end",
"def total_goods(discount_goods)\n #total_info = Hash.new\n total_info = {'total_cost'=>0,'total_discount'=>0}\n discount_goods.each do |item|\n total_info['total_cost'] += item['total_price']\n total_info['total_discount'] += item['discount']\n end\n total_info\n end",
"def discount_on_line_item_total\n total_discount = 0\n\n line_item_promotions.each do |promotion|\n total_discount += discount_for_line_item_promotion(promotion)\n end\n\n total_discount\n end",
"def create\n @item = Item.new(item_params)\n @item.image_url='receipt.jpg'\n puts current_account.accountable_id\n puts current_account.id\n if current_account && current_account.accountable_type == \"Employee\"\n @item.employee = current_account.accountable\n \n \n @item = @cart.add_item(@item)\n respond_to do |format|\n if @item.save\n format.html { redirect_to( company_index_path) }\n @item.update(employee_id: current_account.accountable_id)\n @item.update(actual_expense_date: item_params[:actual_expense_date])\n @item.update(amount: item_params[:amount])\n @item.update(expense_type: item_params[:expense_type])\n\n if item_params[:department] == \"QA\"\n @item.update(department: 1)\n elsif item_params[:department] == \"RnD\"\n @item.update(department: 2)\n else\n @item.update(department: 3)\n end\n\n if item_params[:expense_type] == 'Travel'\n @item.update(expense_type: \"Travel\")\n puts \"\\nTravel\\n\"\n elsif item_params[:expense_type] == 'Taxi'\n @item.update(expense_type: \"Taxi\")\n puts \"\\nTaxi\\n\"\n elsif item_params[:expense_type] == 'Lodging'\n @item.update(expense_type: \"Lodging\")\n puts \"\\nLodging\\n\"\n elsif item_params[:expense_type] == 'Food'\n @item.update(expense_type: \"Food\")\n puts \"\\nFood\\n\"\n else\n @item.update(expense_type: \"Other\")\n puts \"\\nOther\\n\\n\"\n end\n \n\n else\n format.html { render :new }\n format.json { render json: @taf_item.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def total_item\n @items.reject {|item| item.quantity == 0}\n invoice_total = @items.sum {|item| item.sale_price * item.quantity}\n\n end",
"def discountable_item_total\n tot = 0\n self.line_items.each do |li|\n tot += li.total if li.product.taxons.any? {|t| t.name == \"Discountable\"}\n end\n self.item_total = tot\n end",
"def checkout(cart, coupons)\n \n #binding.pry\n \n #use same cart to apply all the different discounts onto otherwise it wont be totaled\n \n \n cart_output = consolidate_cart(cart)\n apply_coupons(cart_output, coupons)\n apply_clearance(cart_output)\n \n grand_total = 0\n\n #binding.pry\n cart_output.each do |item_name, item_details|\n \n #have to get price AND count otherwise items aren't charged repeatedly\n grand_total += item_details[:price] * item_details[:count]\n \n end\n \n #binding.pry\n \n if grand_total > 100.00\n grand_total = ( grand_total * (0.90) ).round(2)\n end \n #binding.pry\n \n grand_total\nend",
"def so_item_totals\n qty = params[:qty].to_f / 10000\n amount = params[:amount].to_f / 10000\n tax = params[:tax].to_f / 10000\n discount_p = params[:discount_p].to_f / 100\n # Bonus\n discount = discount_p != 0 ? amount * (discount_p / 100) : 0\n # Taxable\n taxable = amount - discount\n # Taxes\n tax = tax - (tax * (discount_p / 100)) if discount_p != 0\n # Total\n total = taxable + tax\n # Format output values\n qty = number_with_precision(qty.round(4), precision: 4)\n amount = number_with_precision(amount.round(4), precision: 4)\n tax = number_with_precision(tax.round(4), precision: 4)\n discount = number_with_precision(discount.round(4), precision: 4)\n taxable = number_with_precision(taxable.round(4), precision: 4)\n total = number_with_precision(total.round(4), precision: 4)\n # Setup JSON hash\n @json_data = { \"qty\" => qty.to_s, \"amount\" => amount.to_s, \"tax\" => tax.to_s,\n \"discount\" => discount.to_s, \"taxable\" => taxable.to_s, \"total\" => total.to_s }\n render json: @json_data\n end",
"def update\n respond_to do |format|\n if @item.update(item_params)\n \n\n if current_account.accountable_type == \"Employee\"\n @item.update(ba_reason: nil)\n @item.update(ba_approval: false)\n @item.update(pm_approval: false)\n @item.update(pm_reason: nil)\n end\n\n if item_params[:department] == \"QA\"\n @item.update(department: 1)\n elsif item_params[:department] == \"RnD\"\n @item.update(department: 2)\n else\n @item.update(department: 3)\n end\n \n if current_account.accountable_type == \"BudgetApprover\"\n @item.update(budget_approver_id: current_account.accountable_id)\n\n # if @item.ba_approval == true \n # @total = @[email protected]\n # @dpt = Department.find(@item.department)\n # @dpt.update(available_funds: (@dpt.available_funds - @item.amount))\n \n # else\n # @dpt = Department.find(@item.department)\n # @dpt.update(available_funds: (@dpt.available_funds + @item.amount))\n \n # end\n\n end\n \n if current_account.accountable_type == \"PaymentManager\"\n @item.update(payment_manager_id: current_account.accountable_id)\n \n if @item.pm_approval == true \n @total = @[email protected]\n @dpt = Department.find(@item.department)\n @dpt.update(actual_funds: (@dpt.actual_funds - @item.amount))\n \n else\n @dpt = Department.find(@item.department)\n @dpt.update(actual_funds: (@dpt.actual_funds + @item.amount))\n if @item.pm_approval == true\n \n end\n end\n end\n @item.update(pm_reason: item_params[:pm_reason])\n \n \n format.html { redirect_back(fallback_location: :back) }\n format.json { render :show, status: :ok, location: @item }\n else\n format.html { render :edit }\n format.json { render json: @item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def apply_discount\n if @discount\n discount = @total * @discount / 100 \n @total = @total - discount\n return \"After the discount, the total comes to $#{@total}.\"\n else # cash register wasn't initiailzied w/ discount\n return \"There is no discount to apply.\"\n end\n end",
"def discounted_item_total\n ( self.item_total - self.discountable_item_total )\n end",
"def calculate(items)\n\n\t\titems.each do |item|\n\t\t\ttax_rate = get_tax_rate(item)\n\t\t\ttax = get_tax(item[:price], item[:quantity], tax_rate)\n\t\t\t@total_tax += tax\n\n\t\t\titem[:sales_price] = (item[:price] * item[:quantity] + tax).round(2)\n\t\t\t@total_price += item[:sales_price]\n\t\tend\n\n\t\treturn @total_tax, @total_price\n\tend",
"def coupon_items(cart, coupons)\n\tcost = 0\n\tcart.each do |item|\n\t\titem.each do |name, attributes|\n\t\t#we want to make sure we have the minimum # of items to apply the coupon\n\t\t\tcoupons.each do |coupon|\n\t\t\t\tif name == coupon [:item] && attributes[:count] >= coupon[:num]\n\t\t\t\t#add the item to the total cost\n\t\t\t\tcost += coupon[:cost]\n\t\t\t\t#paid for the number of items reflected in the coupon\n\t\t\t\tattributes[:count] = attributes[:count] - coupon[:num]\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend\n\tcost\nend",
"def discounted_total\n line_items = line_items_total\n fees = [item_fees_in_cents].sum\n credits = [customer_credits_total, promo_code_total].sum\n discounts = [membership_discount_total, quantity_discount_total].sum\n\n total = line_items + fees - credits - discounts\n [total, 0].max\n end",
"def manage_items\n @pending_items = Item.find_all_by_item_status_id(1)\n @for_sale_items = Item.find_all_by_item_status_id(2)\n @free_items = Item.find_all_by_item_status_id(3)\n @claimed_items = Item.find_all_by_item_status_id(4)\n @sold_items = Item.find_all_by_item_status_id(5)\n end",
"def update_amounts\n @items = @items.each do |item|\n item[:good_tax] = set_tax(item[:good], item[:total], @good_tax_rate)\n item[:import_tax] = set_tax(item[:import], item[:total], @import_tax_rate)\n item[:sales_tax] = add_taxes(item[:sales_tax], item[:good_tax], item[:import_tax])\n item[:total] = add_taxes(item[:total], item[:good_tax], item[:import_tax])\n end\n end",
"def checkout\n # get all items in cart\n items = CartItem.where(:cart_id => params[:cart_id])\n pricing_rules = [\"3_FOR_2\", \"3_OR_MORE_TSHIRTS\"]\n co = PB::Checkout.new(pricing_rules)\n #debugger\n #total = 100\n items.each do | item |\n code = Item.find(item[:item_id])[:code]\n co.scan(code)\n end\n # debugger\n @total = co.total()\n end",
"def all_expense_items\n owing_expense_items + paid_expense_items\n end",
"def discount_amount\n all_discounts = line_items.collect { |li| li.discounts }.flatten\n mapping = all_discounts.map(&:price_extend)\n # when we create the discount items, we need to set calculate their price_extend value\n mapping.sum\n end",
"def checkout(cart, total_w_c)\n\n\tunit_price_greater_five = false\n\tcoups = generateCoups\n\tsavings = 0\n\n#\tputs coups.inspect # => [{:item=>\"AVOCADO\", :num=>2, :cost=>5.0}]\n\n\tcoups.each do | coups_item |\n#\tputs coups_item # => {:item=>\"BEER\", :num=>2, :cost=>20.0}\n#\tputs coups[0][:item] #=> CHEESE\n\n\t\tcart.each_pair do | food, traits |\n# \t\tputs traits #=> {:price=>3.0, :clearance=>true, :count=>3}\n\n\n\t\t\tif coups[0][:item] == food\n\t\t\t\t##when checking out, check the coupons and apply the discount if the proper number of items is present\n\t\t\t\tif traits[:count] >= coups[0][:num]\n\t\t\t\t\tsavings += ((traits[:count]/coups[0][:num]) * (traits[:price]-coups[0][:cost]))\n\t\t\t\tend\n\t\t\tend\t\t\n\t\t\t\n\t\t\t##if none of the items purchased have a unit price greater than 5$ give the customer a 10$ discount off the whole cart\n\t\t\tif traits[:count] * traits[:price] > 5\n\t\t\t\tunit_price_greater_five = true\n\t\t\tend\n\n\n\t\tend\n\tend\n\tif unit_price_greater_five == false\n\t\ttotal_w_c -= 10\n\t\tputs \"None of the items purchased have a unit price greater than $5\"\n\t\tputs \"You got a $10 discount.\"\n\tend\t\n#\tputs cart.inspect\n\tputs \"Your original total was $#{total_w_c}.\" if savings != 0 \n\ttotal_w_c += savings \n\tputs \"Your coupon savings for today is $#{savings.abs}\" if savings != 0\n\tputs total_w_c.round(2)\nend",
"def checkout(cart, coupons)\n #call the consolidate to get the count item first\n new_cart = consolidate_cart(cart)\n #apply coupon to the new cart\n apply_coupons(new_cart, coupons)\n #apply clearance after discount from coupon\n apply_clearance(new_cart)\n\ntotal = 0\n new_cart.each do |name, hash|\n total += (hash[:price] * hash[:count])\n #binding.pry\n end\n\nif total >= 100\n total *= 0.9\n end\n\n total\nend",
"def apply_discount\n # checks if there is any discount\n if discount == 0\n \"There is no discount to apply.\"\n else\n #applies discount\n @total = @total * (1-@discount/100.0)\n # converts back to integer\n @total = @total.to_i\n \"After the discount, the total comes to $#{@total}.\"\n end\n end",
"def coupDiscounts\n\t\t@new_cart.each do |item, details|\n\t\t\tcase\n\t\t\t\twhen item == \"CHEESE\" && details[:coups] == 1 && details[:count] > 2\n\t\t\t\t\tdetails[:cost] = (((details[:count] / 3) * 15) + ((details[:count] % 3) * details[:price]))\n\t\t\t\twhen item == \"AVOCADO\" && details[:coups] == 1 && details[:count] > 1\n\t\t\t\t\tdetails[:cost] = (((details[:count] / 2) * 5) + ((details[:count] % 2) * details[:price]))\n\t\t\t\twhen item == \"BEER\" && details[:coups] == 1 && details[:count] > 1\n\t\t\t\t\tdetails[:cost] = (((details[:count] / 2) * 20) + ((details[:count] % 2) * details[:price]))\n\t\t\t\tend\t\t\t\t\n\t\tend\n\tend",
"def big_spender_discount(cart:[])\n cart_total = cart.reduce(0.0) { |total, (item, info)| total += info[:price] * info[:count] }\n cart_total > 100 ? cart_total -= cart_total * 0.1 : cart_total\nend",
"def discounted_total\n line_item.total_in_cents - discount_amount\n end",
"def success\n if session[:purchased_item] == '0'\n @items = items_from_cart\n session.delete(:cart)\n else\n item = Product.find(session[:purchased_item])\n @items = []\n @items << { name: item.name, price: item.price, image: item.product_images[0].image.url(:thumb), quantity: session[:quantity] }\n end\n @sum = 0\n @count = 0\n @items.each do |item|\n @sum += item[:price] * item[:quantity].to_i\n @count += item[:quantity].to_i\n end\n end",
"def calculate_amount_coupon\n sales_id = params[:sale_id_coupon]\n products_ids = params[:info_product_id]\n products_quantity = params[:info_product_quantity]\n products_end_var = Hash.new(\"products\")\n products_new_sale = Hash.new(\"products to new sale\")\n products_coupon = Hash.new(\"products coupon\")\n count = 0\n sale_amount = 0\n limit_date = Date.today + 3.days\n @sale_old = Sale.where(id: sales_id.to_i)\n @sale_old.each do |s|\n @sale_old_id = s.id\n @sale_old_customer= s.customer_id\n end\n\n for i in 0..products_ids.length-1\n j=0\n begin\n j +=1\n products_end_var[products_ids[i]]=products_quantity[count]\n count +=1\n end until j > 0\n end\n\n products_end_var.each_with_index do |(key, value), index|\n if value.to_i >0\n products_coupon[key] = value\n else\n products_new_sale[key] = value\n end\n end\n respond_to do |format|\n #Se crea la nueva venta y los items\n unless products_new_sale.empty?\n @sale = Sale.new\n @sale.user_id = current_user.id\n @sale.discount = 0\n @sale.limit_date = limit_date.strftime('%F')\n @sale.save\n products_new_sale.each_with_index do |(key, value), index|\n id_product= key.to_i\n product = Product.where(id: id_product)\n product.each do |p|\n item = Item.where sale_id: sales_id.to_i, product_id: p.id\n item.each do |i|\n sale_amount += p.price * i.quantity\n @item_created = Item.create product_id: p.id, sale_id: @sale.id ,quantity: i.quantity\n end\n end\n end\n @sale.customer_id = @sale_old_customer\n @sale.amount = sale_amount\n @sale.total_amount = sale_amount\n @sale.save\n end\n\n #Se crea el coupon y los item_coupons\n unless products_coupon.empty?\n coupon_amount = 0\n @coupon = Coupon.new\n @coupon.amount = 1\n @coupon.save\n products_coupon.each_with_index do |(key, value), index|\n id_product= key.to_i\n value_product = value.to_i\n product = Product.where(id: id_product)\n product.each do |p|\n coupon_amount += p.price * value_product\n new_stock_product = p.stock + value_product\n p.update stock: new_stock_product\n item = Item.where sale_id: sales_id.to_i, product_id: p.id\n item.each do |i|\n if i.quantity == value_product\n @new_item_coupon = ItemCoupon.create sale_id: @sale_old_id, coupon_id: @coupon.id, quantity: value_product\n @new_item_coupon.save\n else\n new_item_quantity = i.quantity - value_product\n if new_item_quantity >= 0\n if @sale.nil?\n @sale = Sale.new\n @sale.user_id = current_user.id\n @sale.discount = 0\n @sale.limit_date = limit_date.strftime('%F')\n @sale.save\n end\n @item_created = Item.create product_id: p.id, sale_id: @sale.id ,quantity: new_item_quantity\n @new_item_coupon = ItemCoupon.create sale_id: @sale_old_id, coupon_id: @coupon.id , quantity: value_product\n @new_item_coupon.save\n @item_created.save\n sale_amount += p.price * new_item_quantity\n else\n unless @sale.nil?\n Sale.last.destroy\n end\n Coupon.last.destroy\n @coupon_create = \"no\"\n end\n end\n end\n end\n end\n @coupon.amount = coupon_amount\n @coupon.user_id = current_user.id\n @coupon.save\n unless @sale.nil?\n @sale.amount = sale_amount\n @sale.total_amount = sale_amount\n @sale.state = \"pago\"\n @sale.save\n end\n end\n if @coupon_create == \"no\"\n format.html { redirect_to coupons_url, alert: 'No se pudo realizar el cambio, la cantidad de productos a cambiar es inválida.' }\n format.json { head :no_content }\n elsif @sale.nil?\n #format.js { render :js => \"window.open('/coupons/generate_sale_pdf.pdf?param1=\"[email protected]+\"¶m2=\"[email protected]+\"¶m3=\"+@sale_old_id+\"¶m4=\"[email protected]+\"'),'_blank',window.location.href='/coupons'\"}\n format.html{redirect_to url_for(:controller => :coupons,format: :pdf ,:action => :generate_pdf, :param1 => @coupon, :param2 => @sale, :param3 => @sale_old_id, :param4 => @coupon.amount)}\n @sale_old.each do |sale_old|\n sale_old.anulada!\n end\n else\n unless @coupon.nil?\n #format.js { render :js => \"window.open('/coupons/generate_sale_pdf.pdf?param1=\"[email protected]+\"¶m2=\"[email protected]+\"¶m3=\"+@sale_old_id+\"¶m4=\"[email protected]+\"'),'_blank',window.location.href='/coupons'\"}\n format.html{redirect_to url_for(:controller => :coupons,format: :pdf ,:action => :generate_pdf, :param1 => @coupon, :param2 => @sale, :param3 => @sale_old_id, :param4 => @coupon.amount)}\n @sale_old.each do |sale_old|\n sale_old.anulada!\n end\n end\n format.html { redirect_to coupons_url, alert: 'No se pudo realizar el cambio, no hay productos seleccionados.' }\n end\n end\n end",
"def discount_for_category(line_items)\n item_counter = max_items || 1000\n product_or_group = apply_to_type == 'product' ? apply_to_product.name : apply_to_group\n line_items\n .select { |l| l.send(apply_to_type).to_s == product_or_group }\n .sort_by { |l| -l.unit_price }\n .take(max_items.nil? ? 1000 : max_items)\n .reduce(0) do |sum, line_item|\n total_quantity = max_items.nil? ? line_item.quantity : [item_counter, line_item.quantity].min\n if item_counter < 1\n # If we've gone over our limit for max_items, don't add anymore to the discount\n sum\n else\n item_counter -= total_quantity\n total_amount = amount * total_quantity\n if discount_type == 'fixed'\n sum + (total_amount > line_item.total_price ? line_item.total_price : total_amount)\n elsif discount_type == 'percentage'\n sum + (line_item.unit_price * total_quantity * amount * 0.01).round(2)\n end\n end\n end\n end",
"def calculate\n @item_list.each { |item|\n tax_rate = (item.exempt? ? 0.00 : Constants::NON_IMPORT_TAX_RATE) + (item.imported? ? Constants::IMPORT_TAX_RATE : 0.00)\n total_before_tax = item.qty * item.price\n tax = (total_before_tax * tax_rate).round_to_05\n\n @receipt_tax += tax\n @receipt_total += item.total = total_before_tax + tax\n }\n\n # do final rounding - needed due to Float quirks\n @receipt_tax = @receipt_tax.round(2)\n @receipt_total = @receipt_total.round(2)\n return self\n end",
"def checkout \n number_items = 0\n total = 0\n puts \"ITEMS PRECIO\"\n puts \"\"\n\n get_list.each {\n \t|a| total += a.price \t\n number_items += 1\n puts \"#{a.name} $#{a.price}\"\n\n }\n\n if number_items > 5\n \ttotal_sin_redondeo = 0.9 * total\n \ttotal = total_sin_redondeo.redondear(2)\n end\n\n puts \"You are taking #{number_items} items\"\n puts \"Your total today is $#{total}. Have a nice day!\"\n\n end",
"def run(cart)\n\n return if @discount == 0;\n\n cart.line_items.each do |line_item|\n @discount.apply(line_item)\n end\n end",
"def run(cart)\n\n return if @discount == 0;\n\n cart.line_items.each do |line_item|\n @discount.apply(line_item)\n end\n end",
"def run(cart)\n # Each line_item has a quantity, which usually makes the total...\n # ...quantity of items higher than the length of cart.line_items\n total_item_count = 0\n applicable_line_items = cart.line_items.select do |line_item|\n is_shirt = line_item.variant.product.tags.include? 'shirts'\n is_bundle = line_item.variant.product.tags.include? 'bundle'\n if is_shirt and is_bundle\n total_item_count += line_item.quantity\n line_item\n end\n end\n\n # The remaining amount of items that can be discounted in each category\n items_in_bundles_of_3 = (total_item_count / 3).floor * 3\n items_in_bundles_of_2 = ((total_item_count % 3) / 2).floor * 2\n \n # Change the price of applicable items\n applicable_line_items.each do |line_item|\n unexamined_item_count = line_item.quantity\n if items_in_bundles_of_3 >= unexamined_item_count\n discount = unexamined_item_count * @discount_per_item_in_bundle_of_three\n line_item.change_line_price(line_item.line_price - discount, message: \"\")\n items_in_bundles_of_3 -= unexamined_item_count\n next\n end\n if items_in_bundles_of_3 > 0 and items_in_bundles_of_3 < unexamined_item_count\n discount = items_in_bundles_of_3 * @discount_per_item_in_bundle_of_three\n line_item.change_line_price(line_item.line_price - discount, message: \"\")\n unexamined_item_count -= items_in_bundles_of_3\n items_in_bundles_of_3 = 0\n end\n if items_in_bundles_of_2 >= unexamined_item_count\n discount = unexamined_item_count * @discount_per_item_in_bundle_of_two\n line_item.change_line_price(line_item.line_price - discount, message: \"\")\n items_in_bundles_of_2 -= unexamined_item_count\n end\n end\n end",
"def apply_coupons(cart, coupons)\n # binding.pry\n coupons.each do |coupon|\n item_in_cart = find_item_by_name_in_collection(coupon[:item], cart) \n cart_item_w_coupon = find_item_by_name_in_collection(coupon[:item] + \" W/COUPON\", cart)\n if cart_item_w_coupon && item_in_cart[:count] >= coupon[:num] \n cart_item_w_coupon[:count] += coupon[:num] \n item_in_cart[:count] -= coupon[:num] \n elsif item_in_cart && item_in_cart[:count] >= coupon[:num]\n cart << {\n :item => coupon[:item] + \" W/COUPON\",\n :price => coupon[:cost] / coupon[:num],\n :count => coupon[:num],\n :clearance => item_in_cart[:clearance]\n }\n item_in_cart[:count] -= coupon[:num]\n end \n end\n cart\nend",
"def cost_cal(items)\r\n price = 0\r\n items.item.each do |h|\r\n price += h[:num] * h[:price]\r\n end\r\n #profit = '%.2f' % profit\r\n puts \"Order total: $#{'%.2f' % price}\"\r\n return nil\r\nend",
"def predict_price_after_discounts!\n m_discounts = []\n f = build_discount_items :fixed_amount\n m_discounts += f\n \n self.price_after_fixed_discounts = (self.price * self.qty).to_i + m_discounts.each {|discount| discount.price_extend }.sum(&:price_extend).to_i\n\n p = build_discount_items :percentage\n m_discounts += p\n \n self.price_after_all_discounts = (self.price * self.qty).to_i + m_discounts.each {|discount| discount.price_extend }.sum(&:price_extend).to_i\n \n if self.price_after_all_discounts < 0\n discount_amount = self.price_after_all_discounts * -1\n discount_sku = Product.find_by_name(\"Discount\").sku\n discount_attributes = {:product_sku => discount_sku, :qty => 1, \n :currency_used => \"BTC\", \n :price => discount_amount, :price_extend => discount_amount,\n :description => \"Discount to prevent line_item from less than zero condition\" }\n \n self.discounts.create(discount_attributes)\n end\n \n [self.price_after_all_discounts, m_discounts]\n end",
"def discount\n\t\[email protected] do |code, quantity|\n\t\t\tif code == :SR1 && quantity >= 3\n\t\t\t\t@discount = 4.50\n\t\t\t\tputs \"your strawberry has been reduced of 4.50\"\n\t\t\tend\n\n\t\t\tif code == :GR1 && quantity >=2\n\t\t\t\t@discount = @pricing_rules[code]\n\t\t\t\tputs \"Buy one green tea get one free!\"\n\t\t\tend\n\t\tend\n\t\tapply_discount\n\tend",
"def apply_discount\n # if @discount != 20\n discount_percent = ((100.0 - @discount.to_f) / 100.0)\n @total *= discount_percent\n return \"After the discount, the total comes to $#{@total.to_i}.\"\n # else\n # return \"There is no discount to apply.\"\n # end\n end",
"def profit_cal(items)\r\n profit = 0\r\n items.item.each do |h|\r\n profit += h[:num]*(h[:price] - h[:cost])\r\n end\r\n #profit = '%.2f' % profit\r\n puts \"The total profit is $#{'%.2f' % profit}\"\r\n return nil\r\nend",
"def create\n @transaction = Transaction.new(params[:transaction])\n #@item = Item.find(@transaction.item_id)\n #@item.buyer_id = current_user.id\n @transaction.user_id = current_user.id\n @shopping_cart = ShoppingCart.find_by_user_id(current_user.id)\n error_flag = 0\n error_message = \"\"\n available_item = Array.new\n eval(@shopping_cart.item_list).each do |item_id, quantity|\n item = Item.find(Integer(item_id))\n if item.quantity < quantity\n error_message = \"Sorry! Only #{item.quantity} of #{item.title} is available at the moment\"\n error_flag = 1\n else\n available_item += [item]\n item.quantity -= quantity\n end\n end\n\n if error_flag == 1\n redirect_to @shopping_cart, notice: error_message\n else\n item_list = Hash.new\n eval(@shopping_cart.item_list).each do |item_id, item_quantity|\n index = Item.find(Integer(item_id)).attributes.except(\"created_at\", \"updated_at\", \"product_file_name\",\n \"product_content_type\", \"product_file_size\", \"product_updated_at\")\n item_list[index] = item_quantity\n end\n @transaction.item_list = item_list.to_s\n\n respond_to do |format|\n if @transaction.save\n available_item.each do |item|\n item.save\n end\n @shopping_cart.delete\n format.html { redirect_to @transaction, notice: 'Transaction successful.' }\n format.json { render json: @transaction, status: :created, location: @transaction }\n else\n format.html { render action: \"new\" }\n format.json { render json: @transaction.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def update\n respond_to do |format|\n if @item.update(item_params)\n itemid = @item.id\n @cartitems = CartItem.where(\"item_id = #{itemid}\")\n @cartitems.each do |cartitem|\n cartitem.available = @item.quantity\n cartitem.save\n end\n format.html { redirect_to @item, notice: 'Item was successfully updated.' }\n format.json { render :show, status: :ok, location: @item }\n else\n format.html { render :edit }\n format.json { render json: @item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def total_pay\n total = 0\n @serie_items.each do |item|\n # next if item.quantity.nil?\n total += item.quantity * item.creation.price\n end\n return total\n end",
"def apply_discount\n\t\t@total -= @discount\n\t\tputs \"Total price expected: £ #{@total.round(3)}\"\n\tend",
"def create\n @item = Item.new(purchase_item_params)\n\n item_cost = 2\n\n # if params[:item] == \"coin\" || params[:item] == :coin\n # @item = current_user.items.create(item: params[:item], denomination: params[:denomination])\n # elsif params[:item] == \"die\" || params[:item] == :die\n # item_cost = @item.sides\n # @item = current_user.items.create(item: params[:item], sides: params[:sides], colour: params[:colour])\n # end\n\n alert_text = \"Purchase alert: \"\n if @item.item == \"coin\" || @item.item == :coin\n if @item.sides || @item.sides != 0\n alert_text += \"Ignored number of sides '#{@item.sides}' when purchasing the coin. \"\n end\n if @item.colour || @item.colour != nil || @item.colour != \"\"\n alert_text += \"Ignored colour '#{@item.colour}' when purchasing the coin. \"\n end\n @item = current_user.items.create(purchase_coin_params)\n elsif @item.item == \"die\" || @item.item == :die\n if @item.denomination\n alert_text += \"Ignored denomination '#{@item.denomination}' when purchasing the die. \"\n end\n item_cost = @item.sides\n @item = current_user.items.create(purchase_die_params)\n end\n\n # @item = current_user.items.create(purchase_item_params)\n\n if !item_cost\n alert_text += \"Purchase refused - Please input a number of sides for the die you want to purchase.\"\n flash.now[:alert] = \"#{alert_text}\"\n render :new\n elsif current_user.gems < item_cost\n alert_text += \"Purchase refused - You don't have enough gems. The item costs #{item_cost}, but you only have #{current_user.gems} gems.\"\n flash.now[:alert] = \"#{alert_text}\"\n render :new\n else\n respond_to do |format|\n if @item.save\n current_user.gems -= item_cost\n current_user.save\n\n format.html { redirect_to purchaseitems_path, notice: 'Item was successfully purchased.', alert: alert_text }\n format.json { render :show, status: :created, location: @item }\n else\n format.html { render :new, alert: alert_text }\n format.json { render json: @item.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def total_discounted_price\n # convert to array so it doesn't try to do sum on database directly\n line_items.to_a.sum(&:total_discounted_price)\n end",
"def apply_coupons(cart, coupons)\n coupons.each do |coupon|\n item = coupon[:item] #avocado, cheese,...\n coupon_item=\"#{item} W/COUPON\"\n if cart.has_key?(item) \n if cart[item][:count] >= coupon[:num]\n if !cart[coupon_item] \n cart[coupon_item] ={count: coupon[:num], price: coupon[:cost]/ coupon[:num], clearance: cart[item][:clearance] }\n else\n cart[coupon_item][:count] += coupon[:num]\n end\n cart[item][:count] -= coupon[:num] \n end\n end\n end\n cart\nend",
"def count_item(item)\n # model class for item\n model = item[0].capitalize.constantize\n price = model.price\n amount = item[1]\n price * amount * tax_coefficient(model) * discount_coefficient(item[0])\n end",
"def shopping_list(discount_goods,total_info)\n p '***<没钱赚商店>购物清单***'\n discount_goods.each do |item|\n p \"名称：#{item['name']}，数量：#{item['count']}#{item['unit']}，单价：#{item['price']}(元)，小计：#{item['total_price']}(元)\"\n end\n p '----------------------'\n p '挥泪赠送商品：'\n discount_goods.each do |item|\n if item['discount'] != 0\n p \"名称：#{item['name']}，数量：#{item['count']-item['new_count']}#{item['unit']}\"\n end\n end\n p '----------------------'\n p \"总计：#{total_info['total_cost']}(元)\"\n p \"节省：#{total_info['total_discount']}(元)\"\n p '**********************'\n end",
"def save_invoice_items(tariff, invoice, bill, cf, user_id)\n # Fixed\n fixed_fee_qty = fixed_fee_quantity\n if !tariff.fixed_fee.zero?\n tariff_code = tariff.try(:billable_item).try(:billable_concept).try(:code) rescue ''\n # tariff_price = tariff.fixed_fee / tariff.billing_frequency.total_months\n tariff_price = (tariff.fixed_fee / tariff.billing_frequency.total_months) * coefficient_by_users(tariff, 'F')\n if tariff_code == 'SUM' && should_bill_by_inhabitants_or_endowments?(tariff, 'F')\n tariff_price = tariff_price * subscriber.right_inhabitants_and_endowments\n end\n if tariff_code == 'DEP'\n tariff_price = tariff_price * subscriber.right_equiv_dwelling\n end\n create_invoice_item(tariff,\n invoice.id,\n \"CF\",\n tariff_price,\n fixed_fee_qty,\n tariff.billing_frequency.fix_measure_id,\n tariff.try(:tax_type_f_id),\n tariff.try(:discount_pct_f),\n user_id, '')\n elsif tariff.percentage_fixed_fee > 0 and !tariff.percentage_applicable_formula.blank?\n create_invoice_item(tariff,\n invoice.id,\n \"CF\",\n ((tariff.percentage_fixed_fee/100) * Invoice.find(invoice.id).total_by_concept_ff(tariff.percentage_applicable_formula)) / billing_frequency.total_months,\n fixed_fee_qty,\n tariff.billing_frequency.fix_measure_id,\n tariff.try(:tax_type_f_id),\n tariff.try(:discount_pct_f),\n user_id, '')\n end\n\n # Variables\n # block_frequency = billing_frequency.total_months.to_d / tariff.billing_frequency.total_months.to_d\n block_frequency = coefficient_for_billing_blocks(tariff, fixed_fee_qty)\n if !tariff.block1_limit.nil? && tariff.block1_limit > 0\n limit_before = 0\n block_limit = 0\n (1..8).each do |i|\n block_limit = ((tariff.instance_eval(\"block#{i}_limit\") + coefficient_by_inhabitants(tariff, 'V')) * block_frequency * coefficient_by_users(tariff, 'V')).round rescue nil\n # if limit nil (last block) or limit > consumption\n if block_limit.nil? || block_limit >= (cf || 0)\n create_invoice_item(tariff,\n invoice.id,\n \"BL\"+i.to_s,\n tariff.instance_eval(\"block#{i}_fee\"),\n ((cf || 0) - limit_before),\n tariff.billing_frequency.var_measure_id,\n tariff.try(:tax_type_b_id),\n tariff.try(:discount_pct_b),\n user_id, '')\n break\n else\n create_invoice_item(tariff,\n invoice.id,\n \"BL\"+i.to_s,\n tariff.instance_eval(\"block#{i}_fee\"),\n block_limit - limit_before,\n tariff.billing_frequency.var_measure_id,\n tariff.try(:tax_type_b_id),\n tariff.try(:discount_pct_b),\n user_id, '')\n limit_before = block_limit\n end\n end # (1..8).each\n elsif tariff.percentage_fee > 0 and !tariff.percentage_applicable_formula.blank?\n create_invoice_item(tariff,\n invoice.id,\n \"VP\",\n cf != 0.0 ? (tariff.percentage_fee/100) * Invoice.find(invoice.id).total_by_concept(tariff.percentage_applicable_formula, false) / cf : 0.0,\n cf,\n tariff.billing_frequency.var_measure_id,\n tariff.try(:tax_type_p_id),\n tariff.try(:discount_pct_p),\n user_id, '')\n elsif tariff.variable_fee > 0\n create_invoice_item(tariff,\n invoice.id,\n \"CV\",\n tariff.variable_fee,\n cf,\n tariff.billing_frequency.var_measure_id,\n tariff.try(:tax_type_v_id),\n tariff.try(:discount_pct_v),\n user_id, '')\n end # tariff.block1_limit > 0\n end",
"def index\n @carts_products = current_user.cart.carts_products rescue []\n @cart_total = cart_total\n @cart_total_after_discount = cart_total_after_discount\n @misc_promotional_rule = MiscPromotionalRule.find_by_name('Cart')\n @cart_discount_percentage = 0\n if @misc_promotional_rule\n @cart_discount_percentage = @misc_promotional_rule.discount_percentage if cart_total > @misc_promotional_rule.discount_price\n end\n\n end",
"def calculate_item_liability(item_attributes)\n calculate_item_gross(item_attributes)\n end",
"def clearance_items(cart, cost)\n##defines a new method to update the clearance items. We'll be working with cart and cost.\n\tcart.each do |item|\n\t##for each item in the cart do something with it. We will be refering to this as item.\n\t\titem.each do |name attribute|\n\t\t#for each item, do something with the name attribute.\n\t\t\tif attribute[:clearance]\n\t\t\t##If the attribute has clearance on it do the next line\n\t\t\t\tcost += (attribute[:price] * attribute[:count]) * 0.8\n\t\t\t\t##take the cost and add it or if it is equal to (the attribute cost times the attribute count) times .8\n\t\t\t\tattribute[:count] = 0\n\t\t\t\t##the attribute count is now zero.\n\t\t\tend\n\t\tend\n\tend\n\tcost\nend",
"def apply_clearance(cart)\n # Consult README for inputs and outputs\n #\n # REMEMBER: This method **should** update cart\n cart.each do |item_hash|\n if item_hash[:clearance]\n discount = item_hash[:price] * 0.20\n item_hash[:price] -= discount\n # binding.pry\n end\n end\n cart\nend",
"def total_price\r\n total = 0\r\n\r\n #Adds the prices of the orders up\r\n order_items.each do |order_item|\r\n total += order_item.item.price*order_item.quantity\r\n end\r\n\r\n #Applies any discounts\r\n if(campaign)\r\n discount = campaign.campaign_type.percentage_reduced\r\n if discount != 100\r\n total -= (total * discount / 100)\r\n elsif discount == 100\r\n i = []\r\n order_items.each do |order_item|\r\n i.push(order_item.item.price)\r\n end\r\n total -= i.min\r\n end\r\n end\r\n return total\r\n end",
"def apply_coupons(cart, coupons)\n i = 0\n while i < coupons.length\n item = find_item_by_name_in_collection(coupons[i][:item],cart)\n coupon_item = \"#{coupons[i][:item]} W/COUPON\"\n cart_item_coupon = find_item_by_name_in_collection(coupon_item, cart)\n #binding.pry\n if item && item[:count] >= coupons[i][:num] #if its elgible for a coupon, apply it!\n if cart_item_coupon\n cart_item_coupon[:count] += coupons[i][:num]\n item[:count] -= coupons[i][:num]\n else\n cart_item_coupon = {\n :item => coupon_item,\n :price => coupons[i][:cost]/coupons[i][:num],\n :count => coupons[i][:num],\n :clearance => item[:clearance]\n }\n cart << cart_item_coupon\n item[:count] -= coupons[i][:num]\n #binding.pry\n end\n end\n i += 1\n end\n cart\nend",
"def apply_coupons(cart, coupons)\n copy_item = nil\n original_item_count=0\n text= ' W/COUPON'\n coupon_tot = 0\n\n cart.each do |item|\n coupons.each do |coupon|\n if(item[:item] == coupon[:item] && item[:count] / coupon[:num] >=1)\n original_item_count = item[:count]\n coupuon_tot = (item[:count] / coupon[:num]).floor\n item[:count] = item[:count] - (((item[:count] / coupon[:num]).floor) * coupon[:num])\n copy_item = item.clone\n copy_item[:count] = original_item_count - item[:count]\n copy_item[:item] = copy_item[:item] + text\n copy_item[:price] = coupon[:cost] / coupon[:num]\n cart.push(copy_item)\n end\n end \n end \n cart\nend",
"def update\n respond_to do |format|\n if @servico_item.update(servico_item_params)\n @servico_item.recalcula_total\n @servico_item.save!\n format.html { redirect_to @servico_item, notice: 'Servico item was successfully updated.' }\n format.json { render :show, status: :ok, location: @servico_item }\n else\n format.html { render :edit }\n format.json { render json: @servico_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pay\n\t\titems=get_all_items_in_cart\n\t\tto_be_removed=Array.new\n\t\titems.each do |cart_item|\n\t\t\titem=Item.find(cart_item.fetch(\"table\").fetch(\"cart_item_id\"))\n\t\t\tif item.quantity<cart_item.fetch(\"table\").fetch(\"count\")\n\t\t\t\tflash[:notice] = \"inventory not enough for item: #{item.name}\"\n\t\t\t\tredirect_to :controller => \"cart\", :action => \"index\"\n\t\t\tend\n\t\t\titem.quantity-=cart_item.fetch(\"table\").fetch(\"count\")\n\t\t\titem.save\n\t\t\ttrans=Transaction.new({user_id: User.current_user.id, item_id: item.id, quantity: cart_item.fetch(\"table\").fetch(\"count\"), cost: item.price})\n\t\t\ttrans.save\n\t\t\tto_be_removed.append(item)\n\t\tend\n\t\tto_be_removed.each do |rm_item|\n\t\t\tremove_from_cart(rm_item)\n\t\tend\n\n\t\tflash[:notice] = \"Congratulations! Payment successful!\"\n\n\t\t#flash[:notice] = \"Transaction was completed successfully!!\"\n\n\t\tredirect_to :controller => \"categories\", :action => \"index\"\n\tend",
"def after_taxes\n printed_list = \"\"\n @total = 0\n @list.each do |item, quantity|\n item_total = quantity * item.price\n @total += item_total\n printed_list += \"#{quantity} #{item.name}: #{MONEY_FORMAT % item.price}\\n\"\n end\n return printed_list\n end",
"def apply_discount\n if @discount == 0\n \"There is no discount to apply.\"\n else\n @discounted_price = (self.total * @discount * 0.01)\n @total -= @discounted_price\n \"After the discount, the total comes to $#{@total.to_i}.\"\n end\n end",
"def checkout\n\ttotal = shopping_cart.inject {|sum, item| sum + item.price}\n\n\t...\nend\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>END>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",
"def update_cart_items_accepted\n\t\t\n\t\tif payment_status_changed?\n\n\t\t\tif payment_status == 1\n\t\t\t\tself.cart.cart_credit+= self.amount\n\t\t\telsif payment_status == 0 && payment_status_was == 1\n\t\t\t\t\n\t\t\t\tself.cart.cart_credit-= self.amount\n\t\t\telse\n\n\t\t\tend\n\n\t\t\n\n\t\t\tcart_item_update_results = self.cart.get_cart_items.map{|cart_item| \n\t\t\t\tcart_item.signed_in_resource = self.signed_in_resource\n\t\t\t\t## first all the expected cart items should exist\n\t\t\t\t## then they should all get saved\n\t\t\t\t## none of them should be already accepted.\n\t\t\t\t## if all these conditions are satisfied.\n\t\t\t\t## then we can say that nothing else has happedn\n\t\t\t\t## we do an atomic request\n\t\t\t\t## where(item_id => whatever, accepted => false).set(accepted => true)\n\t\t\t\t## if this fails for even one, then the payment fails.\n\t\t\t\t## and all the remaining cart items -> can be refreshed to show that they are not accepted\n\t\t\t\t## refresh will say -> where(:payment_id => x, and status = acceptd)\n\t\t\t\t## so if some other payment gets in the way, either it will fail or this will fail, so it works.\n\t\t\t\tcart_item.set_accepted(self,nil)\n\t\t\t}.compact.uniq\n\t\t\tself.errors.add(:cart,\"cart item status could not be updated\") if cart_item_update_results[0] == false\n\t\t\n\t\telse\n\t\t\tif (payment_status == 0 || payment_status == 1)\n\t\t\t\tcart_item_update_results = self.cart.get_cart_items.map{|cart_item|\n\t\t\t\t\t#puts \"now mapping cart item\"\n\t\t\t\t\t#puts cart_item.id.to_s \n\t\t\t\t\tcart_item.signed_in_resource = self.signed_in_resource\n\t\t\t\t\tres = cart_item.set_accepted(self,nil)\n\t\t\t\t\tres\n\t\t\t\t}\t\t\t \n\t\t\tend\n\t\tend\n\tend",
"def confirm_order\n @check = Ticket.where(table: session[:table_id]).last\n if @check.nil?\n puts(\"ticket not created yet!\")\n return\n end\n @items = OrderItem.where(:ticket_id => @check.id)\n @check.update(:subtotal => 0)\n\t # Add item totals\n\t comp = 0\n @items.each do |orderItem|\n menu_item = Menuitem.find_by(id: orderItem.item)\n @check.update(:subtotal => (@check.subtotal + menu_item.price))\n\t\tunless orderItem.compitem.nil?\n\t\t\tcomp = comp + orderItem.compitem.amount\n\t\tend\n end\n\n\t \n\t # check reward points\n\t if current_guestaccount\n\t\t # check points\n\t\t if current_guestaccount.points > 4\n\t\t\t @check.update(:subtotal => (@check.subtotal - 10.00))\n\t\t\t @check.update(:points => true)\n\t\t end\n\t\t # check birthday\n\t\t if (current_guestaccount.birthday.month == Time.now.month &&\n\t\t\t current_guestaccount.birthday.day == Time.now.day)\n\t\t\t @check.update(:birthday => true)\n\t\t end\n\t end\n\t \n\t # check birthday discount\n\t if @check.birthday\n\t\t @check.update(:subtotal => (@check.subtotal - 10.00))\n\t end\n\t \n\t # check coupon\n\t if @check.coupon\n\t\t @check.update(:subtotal => (@check.subtotal - 10.00))\n\t end\n\n\t #adjust subtotal for comp\n\t @check.update(:subtotal => (@check.subtotal - comp))\n unless @check.compticket.nil? \n @check.update(:subtotal => (@check.subtotal - @check.compticket.amount))\n end\n\n\t # subtotal cannot be negative\n\t if @check.subtotal < 0\n\t\t @check.update(:subtotal => 0)\n\t end\n\n\t # calculate tax\n\t @check.update(:tax => (@check.subtotal * 0.0825))\n\t \n\t unless @check.gratuity.nil?\n\t\t @check.update(:total => (@check.subtotal + @check.tax + @check.gratuity))\n\t else\n\t @check.update(:total => (@check.subtotal + @check.tax))\n\t end\n end",
"def confirm\n elements=CartItem.where(:cart_id=>current_user.cart.id)\n\n # if there are no items in the cart, the order will not be placed\n if elements.length==0\n redirect_to carts_path, :notice => \"EMPTY CART!!!\"\n end\n\n # Checks to see if any item in the cart is low in stock. If so, abort. If not, update the sales, and stock quantity of the items\n out_of_stock_items=Item.check_validity(elements)\n\n # This actually checks if any items are below stock\n if out_of_stock_items.length!=0\n redirect_to carts_path, :notice => Item.show_low_stock_message(out_of_stock_items)\n else\n # Save the changes in sales and stocks.\n Item.save_sales(elements)\n #after all the validations are processed, the pre-place order view will be rendered\n @item_list=CartItem.where(:cart_id => current_user.cart.id)\n end\n end",
"def apply_coupons(cart, coupons)\n counter = 0\n # doesn't break if there is no coupon\n while counter < coupons.length\n # check coupons to see if it matches any of our cart items\n cart_item = find_item_by_name_in_collection(coupons[counter][:item], cart)\n # does the coupon item exist in the cart? change name to add \"W/COUPON\"\n couponed_item_name = \"#{coupons[counter][:item]} W/COUPON\"\n cart_item_with_coupon = find_item_by_name_in_collection(couponed_item_name, cart)\n # checks if the item is in the cart and that the count satisfies the coupon reqs\n # doesn't break if the coupon doesn't apply to any items\n if cart_item && cart_item[:count] >= coupons[counter][:num]\n # can apply multiple coupons\n if cart_item_with_coupon\n cart_item_with_coupon[:count] += coupons[counter][:num]\n cart_item[:count] -= coupons[count][:num]\n else\n # adds the coupon price to the property hash of couponed item\n cart_item_with_coupon = {\n :item => couponed_item_name,\n # adds the coupon price to the property hash of couponed item\n :price => coupons[counter][:cost] / coupons[counter][:num],\n # adds the count number to the property hash of couponed item\n :count => coupons[counter][:num],\n # remembers if the item was on clearance\n :clearance => cart_item[:clearance]\n }\n cart << cart_item_with_coupon\n # removes the number of discounted items from the original item's count\n cart_item[:count] -= coupons[counter][:num]\n end\n end\n counter += 1\n end\n cart\nend",
"def apply_coupons(cart, coupons)\ni = 0\nwhile i<coupons.length\n cart_item = find_item_by_name_in_collection(coupons[i][:item], cart)\n couponed_item_name = \"#{coupons[i][:item]} W/COUPON\"\n cart_item_with_coupon = find_item_by_name_in_collection(couponed_item_name, cart)\n if cart_item && cart_item[:count] >= coupons[i][:num]\n if cart_item_with_coupon\n cart_item_with_coupon[:count] += coupons[i][:num ]\n cart_item -= coupons[i][:num]\n else\n cart_item_with_coupon =\n { :item=>couponed_item_name,\n :price=>coupons[i][:cost] / coupons[i][:num],\n :count => coupons[i][:num],\n :clearance=>cart_item[:clearance]\n }\n cart << cart_item_with_coupon\n cart_item[:count] -= coupons[i][:num]\n\n end\n\n end\n i += 1\nend\ncart\nend",
"def update_items\n @goods_receive_note = GoodsReceiveNote.find(params[:id])\n params[:item] ||= []\n if params[:commit] == \"Update Items\"\n errors = @goods_receive_note.update_items(params[:item])\n if errors.empty?\n flash[:notice] = \"Goods Receive Note Item was successfully update\"\n else\n flash[:error] = errors\n end\n elsif params[:commit] == \"Remove Items\"\n @goods_receive_note.remove_item(params[:item])\n flash[:notice] = \"Goods Receive Note Item was successfully removed\"\n end\n redirect_to @goods_receive_note\n end",
"def save_item_bonus\n features_sum(:item_save)\n end",
"def apply_coupon\n if self.behavior == 'coupon'\n item = self.item\n \n # coitem is the OrderItem to which the coupon acts upon\n coitem = self.order.order_items.visible.find_by_sku(item.coupon_applies)\n log_action \"apply_coupon: coitem was not found\" and return if coitem.nil?\n\n unless coitem.coupon_amount.zero? then\n log_action \"apply_coupon: This item is a coupon, but a coupon_amount has already been set\"\n return\n end\n \n log_action \"apply_coupon: Starting to apply coupons. total before is #{ coitem.total_cents }\"\n \n ctype = self.item.coupon_type\n if ctype == 1\n # percent rebate\n factor = self.price_cents / 100.0 / 100.0\n if self.vendor.net_prices\n coitem.coupon_amount_cents = coitem.net.fractional * factor\n else\n coitem.coupon_amount_cents = coitem.gross.fractional * factor\n end\n log_action \"apply_coupon: Applying Percent rebate coupon: price_cents is #{ self.price_cents }, factor is #{ factor }, coupon_amount_cents is #{ coitem.coupon_amount_cents }\"\n elsif ctype == 2\n # fixed amount\n coitem.coupon_amount_cents = self.price_cents\n log_action \"apply_coupon: Applying Fixed amount coupon: coupon_amount_cents is #{ coitem.coupon_amount_cents }\"\n elsif ctype == 3\n # buy x get y free\n log_action \"apply_coupon: Applying B1G1\"\n x = 2\n y = 1\n if coitem.quantity >= x\n if self.vendor.net_prices\n coitem.coupon_amount_cents = y * coitem.net.fractional / coitem.quantity\n else\n coitem.coupon_amount_cents = y * coitem.gross.fractional / coitem.quantity\n end\n log_action \"apply_coupon: Applying B1G1 coupon: coupon_amount_cents is #{ coitem.coupon_amount_cents }\"\n end\n end\n if self.vendor.net_prices\n coitem.total = coitem.net - coitem.coupon_amount\n else\n # log_action \"XXXXXXXXX #{ coitem.gross.inspect } #{ coitem.coupon_amount.inspect }\"\n coitem.total = coitem.gross - coitem.coupon_amount\n end\n log_action \"apply_coupon: OrderItem Total after coupon applied is: #{coitem.total_cents} and coupon_amount is #{coitem.coupon_amount_cents}\"\n coitem.calculate_tax\n coitem.save!\n else\n self.total -= self.coupon_amount\n end\n end",
"def initialize(discount = 0)\n @total = 0\n @discount = discount\n @items = []\n end",
"def initialize(discount = 0)\n @total = 0\n @discount = discount\n @items = []\n end",
"def apply_discount\n if self.discount > 0\n self.total = @total - @total * @discount / 100\n return \"After the discount, the total comes to $#{@total}.\"\n else\n return \"There is no discount to apply.\"\n end\n end",
"def update\n\t\tif @item.update(item_params)\n\t\t\trender :json => @item.to_json(methods: [:total_cost])\n\t\telse\n\t\t\trender json: @item.errors, status: :unprocessable_entity\n\t\tend\n\tend",
"def apply(product, items_bought)\n if items_bought < @threshold\n 0\n else\n percent = BigDecimal((@percent/100.to_f).to_s)\n discounted_items = BigDecimal((items_bought - @threshold).to_s)\n percent * discounted_items * product.price\n end\n end",
"def apply_discount\n # conditional to check if there's a discount\n if discount > 0\n @total -= @total * (discount / 100.0).to_f\n #gets rid of trailing zeros \n total = @total.to_s.sub(/\\.?0+$/, '')\n return \"After the discount, the total comes to $#{total}.\"\n else\n return \"There is no discount to apply.\"\n end\n end",
"def collection_discount(total)\n (discount * total) / 100\n end",
"def discounted_items_to_find(total_items_seen, discounted_items_seen)\n Integer(total_items_seen / (@paid_item_count + @discounted_item_count) * @discounted_item_count) - discounted_items_seen\n end",
"def discounted_items_to_find(total_items_seen, discounted_items_seen)\n Integer(total_items_seen / (@paid_item_count + @discounted_item_count) * @discounted_item_count) - discounted_items_seen\n end",
"def discounted_items_to_find(total_items_seen, discounted_items_seen)\n Integer(total_items_seen / (@paid_item_count + @discounted_item_count) * @discounted_item_count) - discounted_items_seen\n end",
"def initialize(discount = 0)\n @total = 0\n @discount = discount\n @items = []\n @price = []\n end",
"def total_amount\n \t amount = 0\n \t operation_items.each do | oi |\n \t\tamount = amount + oi.amount\n end\n amount\n end",
"def large_lp_package_discount(items)\n counter = 1\n all_large_lp_packages = find_all_large_packages_by_lp(items)\n all_large_lp_packages.each_with_index do |item, index|\n # Checking number of large items in a month\n if DateTime.parse(item['Date']).month == DateTime.parse(all_large_lp_packages[index - 1]['Date']).month\n counter += 1\n # Don't care about the actual count, just care if its 3 and if it is then apply the discount.\n counter == 3 ? item['FinalPrice'] = 0.00 : ''\n else\n counter = 1 # Resetting counter if it is a new month\n end\n end\nend",
"def apply_coupons(cart, coupon_array)\n # code here\n\n##coupon count block to account for multiple coupons, and increment them\ncoupon_update_array = []\n coupon_update_hash = {}\n coupon_count = Hash.new(0)\n\n coupon_array.each do |coupon_element|\n coupon_element.each do |key, value|\n if key == :item\n coupon_count[value] += 1\n end\n end\nend\n\ncoupon_array.each do |coupon_element|\n coupon_element.each do |item, avocado|\n coupon_count.each do |name, count|\n if avocado == name\n coupon_update_hash[coupon_element] = count\n end\n end\n end\nend\n\ncoupon_update_hash.each do |coupon_info, count|\n coupon_info[:total_count] = 0\n coupon_info.merge!(:count => count)\nend\n\ncoupon_update_hash.each do |coupon_info, count|\n coupon_info.each do |key, value|\n if key == :num\n coupon_info[:total_count] = count * value\n end\n end\nend\n\n#The code below takes care of multiple coupons for not having enough items to take advantage of the sale\n# If this is the case, the coupon_update_hash information is adjusted to delete coupons that\n# will not be eligible for use, since the client may not have enough items in their cart.\ncart.each do |item, item_info|\n coupon_update_hash.each do |coupon_info, count|\n coupon_info.each do |coupon_key, coupon_value|\n if coupon_key == :item && item == coupon_value\n item_info.each do |item_key, item_value|\n if item_key == :count\n coupon_info.each do |coupon_key1, coupon_value1|\n if coupon_key1 == :total_count && coupon_value1 > item_value\n coupon_info.each do |coupon_key2, coupon_value2|\n if coupon_key2 == :num\n coupon_info[:total_count] = coupon_value1 - coupon_value2\n end\n if coupon_key2 == :count\n coupon_info[:count] = coupon_value2 - 1\n end\n end\n end\n end\n end\n end\n end\n end\n end\nend\n\n\n## Block below will return the cart in the event that no coupons are given,\n #or no coupons apply\n coupon_names = []\n coupon_array.each do |coupons|\n coupons.each do |food_key, food_data|\n if food_key == :item\n coupon_names.push(food_data)\n end\n end\n end\n\n coupons_that_apply_to_cart = []\n cart.each do |food_name, food_data|\n if coupon_names.include?(food_name)\n coupons_that_apply_to_cart.push(food_name)\n end\n end\n if coupons_that_apply_to_cart.length == 0\n return cart\n end\n\n##This block will return the cart if they are not enough items in the cart\n## for the coupon to apply. This method does not account for multiple coupons\n## it looks at one coupon at a time. The method above accounts for the multiple coupons.\n## This method counts the items in the cart\n food_item_count = []\n cart.each do |food_name, food_info|\n coupons_that_apply_to_cart.each do |coupon_name|\n if food_name == coupon_name\n food_info.each do |key, value|\n if key == :count\n food_item_count.push({food_name => value})\n end\n end\n end\n end\n end\n\n # This method counts the items that you need to apply the coupon\n food_coupon_count = []\n coupon_update_hash.each do |coupon_data, count|\n coupon_data.each do |key, value|\n coupons_that_apply_to_cart.each do |coupon_name|\n if key == :item && value == coupon_name\n coupon_data.each do |key, value|\n if key == :num\n food_coupon_count.push({coupon_name => value})\n end\n end\n end\n end\n end\n end\n\n #This method compares the items in the cart, with the items needed to apply the coupon\n # If the item's count in the cart is greater than or equal to the required coupon count\n # The item gets pushed to the qualifying_coupons_based_on_count array.\n qualifying_coupons_based_on_count = []\n food_coupon_count.each do |coupon_info|\n food_item_count.each do |food_info|\n coupon_info.each do |coupon_name, count_coupon|\n food_info.each do |food_name, count_food|\n if food_name == coupon_name && count_food >= count_coupon\n qualifying_coupons_based_on_count.push({coupon_name => count_coupon})\n end\n end\n end\n end\n end\n\n #If the qualifying_coupons_based_on_count array's length is zero, we return the cart since\n #although the customer may have items that are on sale, they have not bought the appropriate\n # quantities to qualify for the special price\n if qualifying_coupons_based_on_count.length == 0\n return cart\n end\n\n ## This block of code checks to see if there is any discrepancy between the qualifying_coupons_based_on_count\n # and the coupons_that_apply_to_cart array. If there are any mismatches, we edit the\n # coupons_that_apply_to_cart array, to make sure we do not include them in the final cart\n qualifying_coupons_based_on_count.each do |qualifying_coupon|\n qualifying_coupon.each do |coupon_name, count|\n if !coupons_that_apply_to_cart.include?(coupon_name)\n coupons_that_apply_to_cart.delete(coupon_name)\n end\n end\n end\n\n# This block adds the updated items with the correct format, and\n# skeleton\n\n coupon_item = \"\"\n coupons_that_apply_to_cart.each do |coupon_name|\n coupon_item = coupon_name + \" W/COUPON\"\n cart[coupon_item] = {:price => 0, :clearance => 0, :count => 0}\n end\n\n coupon_array.each do |coupon_element|\n coupon_element.each do |coupon_key, coupon_data|\n coupons_that_apply_to_cart.each do |coupon_name|\n if coupon_key == :item && coupon_data == coupon_name\n coupon_element.each do |coupon_key, coupon_data|\n if coupon_key == :cost\n cart[coupon_name + \" W/COUPON\"][:price] = coupon_data\n end\n end\n end\n end\n end\n end\n\n\n## This block will take care of the clearance\n cart.each do |avocado, avocado_info|\n avocado_info.each do |price, price_info|\n coupons_that_apply_to_cart.each do |coupon_name|\n if price == :clearance && avocado == coupon_name\n cart[coupon_name + \" W/COUPON\"][:clearance] = price_info\n end\n end\n end\n end\n\n## This block will take care of updating the counts for the couponed items\n coupon_update_hash.each do |coupon_info, count|\n coupon_info.each do |item, item_name|\n coupons_that_apply_to_cart.each do |coupon_name|\n if item == :item && item_name == coupon_name\n coupon_info.each do |item1, item_name1|\n if item1 == :count\n cart[coupon_name + \" W/COUPON\"][:count] = item_name1\n end\n end\n end\n end\n end\n end\n\n## update counts for remainder items that were left as a result of not fitting coupon_info\n## parameters\n cart.each do |food_name, food_info|\n food_info.each do |food_key, food_value|\n coupon_update_hash.each do |coupon_info, count|\n coupon_info.each do |coupon_key, coupon_value|\n if coupon_key == :item && coupon_value == food_name\n coupon_info.each do |coupon_key, coupon_value|\n if food_key == :count && coupon_key == :total_count\n cart[food_name][:count] = food_value - coupon_value\n end\n end\n end\n end\n end\n end\n end\nreturn cart\nend"
] | [
"0.71192497",
"0.6838979",
"0.67270625",
"0.657363",
"0.6438931",
"0.64371127",
"0.64347684",
"0.6391531",
"0.6341032",
"0.62799567",
"0.6277437",
"0.62678355",
"0.6240369",
"0.62104785",
"0.6193512",
"0.6191669",
"0.6188366",
"0.61827564",
"0.61759144",
"0.6169311",
"0.61647856",
"0.6142414",
"0.61319447",
"0.6131445",
"0.6103602",
"0.60988957",
"0.60691804",
"0.60574764",
"0.60320604",
"0.6017233",
"0.5991294",
"0.59770095",
"0.59716785",
"0.597108",
"0.5970685",
"0.59698826",
"0.5961664",
"0.5955862",
"0.59508854",
"0.5949486",
"0.5949127",
"0.59262264",
"0.5926069",
"0.5923156",
"0.5922024",
"0.59186375",
"0.5908038",
"0.59036285",
"0.5900659",
"0.5900659",
"0.5898892",
"0.5898061",
"0.5894507",
"0.58878493",
"0.5886309",
"0.58686054",
"0.5867181",
"0.58372456",
"0.58261436",
"0.5825111",
"0.58199114",
"0.5815281",
"0.581425",
"0.5796823",
"0.5794111",
"0.5792554",
"0.57925224",
"0.57923573",
"0.5787292",
"0.57870936",
"0.57863307",
"0.5782851",
"0.5781368",
"0.5771641",
"0.5770411",
"0.5769456",
"0.5760873",
"0.5759307",
"0.57592887",
"0.57573146",
"0.57547164",
"0.5754034",
"0.57499325",
"0.5729667",
"0.57273656",
"0.57262015",
"0.5723463",
"0.56974715",
"0.56974715",
"0.5694211",
"0.56882626",
"0.5687271",
"0.5685523",
"0.56837076",
"0.56836504",
"0.56836504",
"0.56836504",
"0.56819093",
"0.5675938",
"0.56737703",
"0.56731963"
] | 0.0 | -1 |
void_last_transaction subtracts the last transaction from the total | def void_last_transaction
@total-=self.total
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def void_last_transaction\n @total = @total - @last_transaction_amt\n end",
"def void_last_transaction\n self.total = self.total - self.last_transaction\n end",
"def void_last_transaction\n self.total = self.total - self.last_transaction\n end",
"def void_last_transaction\n self.total = self.total - self.last_transaction\n end",
"def void_last_transaction\n self.total -= @last_transaction.pop\n end",
"def void_last_transaction\n #binding.pry\n @total = @total - @last\n end",
"def void_last_transaction\n @items = self.last_item\n self.total = @total - @transactions[-1]\n end",
"def void_last_transaction\n @total -= @void_last_transaction[1] * @void_last_transaction[2] # subtracts the last transaction from the total\n @void_last_transaction[2].times do\n @items.delete_at(@items.index(@void_last_transaction[0]) || @items.count)\n end\n end",
"def void_last_transaction\n @total -= @prices #subtract prices from the total price\n end",
"def void_last_transaction\n @items.slice!(@items.length-@last_qty, @items.length)\n @total -= @last_transaction.values[0]\n end",
"def void_last_transaction\n self.total -= self.last_item * self.last_quantity\n self.cart.pop\n if self.cart.length <= 0\n self.total = 0.0\n end\n # binding.pry\n end",
"def void_last_transaction\n @items.pop\n @total -= @transactions.pop\n end",
"def void_last_transaction\n transaction = @transactions.pop\n self.total -= (transaction.price * transaction.quantity)\n transaction.quantity.times{self.items.delete(transaction.item_name)}\n end",
"def void_last_transaction\n #binding.pry\n @total -= @last_price * @last_quantity\n @last_quantity.times do\n @items.pop\n end\n\n end",
"def void_last_transaction\n#save add item to last transaction\n#take total and items list, and remove last transaction\n self.total -= self.last_transaction\n @title.pop\n end",
"def delete_transaction \n current_user = self.user\n transactions = Transaction.all\n\n # Current transaction is the only transaction, delete.\n if transactions.count <= 1\n self.delete\n else\n # Get the last transaction and update the total.\n last_transaction = Transaction.last\n \n case current_user \n when USERS.first\n new_total = last_transaction.total - self.amount\n when USERS.last\n new_total = last_transaction.total + self.amount\n end\n \n # If the last transation is the last transaction,\n # edit the total for the second to last transaction.\n if self == transactions[-1]\n second_to_last_transaction = transactions[-2]\n second_to_last_transaction.update({:total => new_total})\n else \n last_transaction.update({:total => new_total})\n end\n self.delete\n end\n end",
"def last_transaction\n @last_transaction ||= self.job_transactions.order(\"modified_date DESC\").first\n end",
"def actual_balance\n if previous.present?\n previous.balance_amount_with_sign\n else\n 0\n end\n end",
"def getOutcomeLast30\n Transaction.where(status: 'DONE', from_account: self.id, updated_at: (Time.now.midnight - 30.day)..Time.now.midnight).map(&:amount).sum\n end",
"def rollback\n current_transaction.rollback\n last_transaction = @all_transactions.pop\n end",
"def rollback_balance(transaction)\n if transaction.succeeded?\n sign = transaction.payment? ? -1 : 1\n self.balance.update_attributes!(amount: (self.balance.amount + (BigDecimal.new(transaction.amount_was) * sign)))\n end\n end",
"def last_trx_number\n @trx_number\n end",
"def balance\n transactions.inject(0) do |sum, transaction|\n sum + transaction.amount\n end\n end",
"def getIncomeLast30\n Transaction.where(status: 'DONE', to_account: self.id, updated_at: (Time.now.midnight - 30.day)..Time.now.midnight).map(&:amount).sum\n end",
"def refund_amount\n\t\treturn 0 unless get_cart_pending_balance < 0\n\t\treturn get_cart_pending_balance\n\tend",
"def balance\n transactions.inject(:+)\n end",
"def store_credit_maximum_amount\n item_total - 0.01\n end",
"def complete_transaction(trans)\n trans = trans.split('>')\n\n return 1 if trans.size != 2\n\n s = trans[0]\n r = trans[1].split('(')[0]\n x = trans[1].split('(')[1].chomp(')')\n\n return 1 unless s.length == r.length && s.length == 6 && x.to_i.to_s == x\n\n sender = @wallets[s.to_i]\n recipient = @wallets[r.to_i]\n x = x.to_i\n\n # update sender wallet\n if @wallets[s.to_i].nil?\n @wallets[s.to_i] = Wallet.new(s, x * -1)\n else\n sender.balance -= x\n @negs.push(sender) if sender.address != 'SYSTEM' && sender.balance.negative?\n end\n\n # update recipients wallet\n if @wallets[r.to_i].nil?\n @wallets[r.to_i] = Wallet.new(r, x)\n else\n recipient.balance += x\n end\n\n @actives.add(s)\n @actives.add(r)\n end",
"def end_balance\n return @end_balance if defined?(@end_balance)\n to_rewind = []\n found = nil\n\n # find the last recorded balance_amount\n prepared.reverse.each do |s|\n if s.balance_amount.present?\n found = s.balance_amount_with_sign\n break\n end\n to_rewind << s\n end\n\n if found.present?\n # rewind forward\n to_rewind.each do |s|\n found += s.amount_with_sign\n end\n end\n\n @end_balance = found\n end",
"def amount_out(date = nil)\n n = 0\n @transactions.each do |t|\n n += t.amount if t.adjusted_amount < 0\n end\n\n n\n end",
"def return_sum\n @money = 0\n @transactions.each do |t|\n if t.get_action == 'buy'\n @money = @money + t.get_value\n elsif t.get_action == 'sell'\n @money = @money - t.get_value\n end\n end\n total_value_of_shares - @money\n end",
"def second_payment_sum\n total_sum - first_payment_sum\n end",
"def log_missing_elapsed_transaction_time\n # rubocop:disable Style/SafeNavigation\n transaction_name = transaction_name = Tracer.current_transaction &&\n Tracer.current_transaction.best_name ||\n 'unknown'\n # rubocop:enable Style/SafeNavigation\n NewRelic::Agent.logger.warn(\"Unable to calculate elapsed transaction time for #{transaction_name}\")\n end",
"def test_transactions_system_not_last\r\n account_tracker = Minitest::Mock.new('test_account_tracker')\r\n block_checker = Minitest::Mock.new('test_block_checker')\r\n block_checker.expect(:parse, [\"123457>123456(100)\"], [\"123457>123456(100)\", \":\"])\r\n block_checker.expect(:parse, [\"123457\", \"123456(100)\"], [\"123457>123456(100)\", \">\"])\r\n block_checker.expect(:parse, [\"123456\", \"100)\"], [\"123456(100)\", \"(\"])\r\n block_checker.expect(:check_digits, true, [\"123457\"])\r\n block_checker.expect(:check_digits, true, [\"123456\"])\r\n block_checker.expect(:get_coins, \"100\", [\"123456(100)\"])\r\n def block_checker.check_coins(string); 100; end\r\n def block_checker.check_last_char(string, char); nil; end\r\n output = \"Line 1: The last transaction may only be from the system: \\'123457>123456(100)\\'\"\r\n assert_equal output, @g.transactions( '123457>123456(100)', account_tracker, block_checker, 1)\r\n end",
"def give_back_money\n if(@transaction.sender)\n @transaction.sender.balance += @transaction.amount\n @transaction.sender.save\n \n end\n\n if(@transaction.receiver)\n @transaction.receiver.balance -= Monetize.parse(convert(Money.new(@transaction.amount,findCurrency(@transaction.sender_id,@transaction.receiver_id,'sent')), @transaction.receiver.currency)).fractional\n @transaction.receiver.save\n end\n end",
"def execute_transaction\n if self.valid?\n @sender.balance -= @amount\n @receiver.balance += @amount\n @amount -= @amount\n @status = \"complete\"\n else\n @status = \"rejected\"\n \"Transaction rejected. Please check your account balance.\"\nend\nend",
"def subtract(cash)\n @current_balance = @current_balance - cash\n end",
"def latest_block(blockchain)\n blockchain[-1]\n end",
"def amount_after_tax\n if waitlist_deduct_amount.present?\n amount_after_discounted + amount_of_tax - waitlist_deduct_amount\n else\n amount_after_discounted + amount_of_tax\n end\n end",
"def remaining_total\n total\n end",
"def current_balance\n starting_balance + transactions.sum(:amount)\n end",
"def total_without_tax\n sub_total - tax_amount\n end",
"def finalize\n @transactions.sort! { |a, b| a.date <=> b.date }\n balance = Value.new(0)\n @balances = @transactions.map do |act_txn|\n balance += act_txn.value\n {\n date: act_txn.date,\n value: balance,\n }\n end\n end",
"def store_credit_maximum_amount\n item_total\n end",
"def last_rut; end",
"def total_amount\n t = amount\n t += sub_transactions.sum(:amount) if recurring_period\n t\n end",
"def final_bill\n total + tax + @tip_amount\n end",
"def dumptotal\n # expire > 15minute dumps\n @dumptrack.reject! { |r| (r[3] + 900) < Time.now }\n total = 0\n @dumptrack.each do |t|\n if t[2] == \"bid\"\n total += t[0].to_i\n elsif t[2] == \"ask\"\n total -= t[0].to_i\n else\n debug(\"failed to match #{t[2]} trade type for total.\")\n end\n end\n # get 5 minute\n alert_msg = \"Sum of whale action; In the last 15 minutes:\"\n add_message(\"*** 15 minute whale action is over the 375 btc threshold! #{total} BTC (alert sleep timer set 1000s)\") if total.abs >= 375\n if total > 0\n return alert_msg + \" + #{total.abs} BTC (bought)\"\n elsif total < 0\n return alert_msg + \"- #{total.abs} BTC (sold)\"\n else\n return \"Last 15 minutes: nothing happening..\"\n end\n end",
"def current_transaction\n @transactions[Thread.current].last\n end",
"def remaining_amount\n if accumulated >= amount\n 0\n else\n (amount - accumulated)\n end\n end",
"def remainder_to_pay\n self.total_amount - self.checkout_wallet.unconfirmed_value_paid\n end",
"def balance\n\t\tbalance = 0\n\t\[email protected] do |transaction|\n\t\t\tbalance += transaction[:amount]\n\t\tend\n\t\treturn balance\n\tend",
"def finish_transaction!\n threadlocal_graph_info[:tx_depth] -= 1 rescue nil\n end",
"def end_date\n @transactions.empty? ? nil : sorted_transactions.last.transaction_at\n end",
"def place_bet(amount)\n @total_money -= amount\n end",
"def last_trade_price\n quote.last_trade_price\n end",
"def final_amount\n amount_paid - discount_value - discount_percent\n end",
"def reverse transaktion\n decrement!(:balance, transaktion.amount) if transaktion.deposit?\n increment!(:balance, transaktion.amount) if transaktion.withdrawal?\n end",
"def gettransactionamount\r\n @transactionamount\r\n end",
"def pop_transaction\n @transactions[Thread.current].pop\n end",
"def check_out\n @cart.each_with_index do |item, i|\n puts \"#{i + 1}) #{item[:name]} - $#{item[:price]}\"\n end\n def tally_up\n @total = @cart.inject(0) {|sum, hash| sum + hash[:price]}\n @totalWithTax = @total * @sales_tax\n puts \"You owe us #{@totalWithTax}!\"\n sleep(2)\n end\n def payment\n if TotalWithTax >= @card_balance\n puts \"Your transaction has been declined\"\n remove_items\n else\n puts \"Thank you for shopping at The Grocery Store\"\n exit\n end\n end\n tally_up\n payment\nend",
"def balance_delta\n prepared.map(&:amount_with_sign).reduce(:+)\n end",
"def current_transaction\n @transactions[Thread.current].last\n end",
"def after_calculate_total(total, _test_digits)\n return total\n end",
"def deduct\n @balance -= @journey_log.fare\n end",
"def cumulative_total_after_tax\n amount = 0.0\n @products_in_cart.each do |product|\n amount += product.total\n end#each\n return amount\nend",
"def pop_transaction\n @transactions[Thread.current].pop\n end",
"def tx_rollback\n write_bytes FrameBytes.tx_rollback(@id)\n expect :tx_rollback_ok\n nil\n end",
"def payment\n payment = 0\n transactions = finance_transactions\n unless transactions.nil?\n transactions.each do |t|\n payment += t.amount\n end\n end\n payment\n end",
"def last_payment\n @last_payment ||= payments.order(:created_at).last\n end",
"def rollback_transaction(tx)\n # nothing to do\n end",
"def withdrawal(t)\n if (@balance - t.amount) < 0\n #print error message\n puts \"#{t.date} Overdraft: Unable to complete transaction to #{t.payee} for #{t.amount}\"\n\n else\n @balance = @balance - t.amount\n t.currBalance = @balance\n @ledger << t\n\n end\n end",
"def balance\n @balance ||= starting_balance + transactions.inject(0) do |result, element|\n result + element.amount\n end\n end",
"def latest_commit\n update_prev_latest_commit\n @latest_commit\n end",
"def reset_transactions\n @transactions_remaining = MAX_TRANSACTIONS\n end",
"def execute_transaction\n if valid?\n self.sender.balance -= self.amount\n self.receiver.balance += self.amount\n self.status = 'complete'\n elsif !valid?\n self.status = 'rejected'\n return \"Transaction rejected. Please check your account balance.\"\n end\n end",
"def subtract_amount_from(transactions, value)\n transactions.each do |transaction|\n new_balance = transaction.account_balance - value\n transaction.update(:account_balance => new_balance)\n end\n end",
"def balance\n balance = 0.00\n @transactions.each do | transaction|\n balance += transaction[:amount]\n end\n return balance\n end",
"def total_amount\n @total_amount ||= data_analyzer.total_amount\n end",
"def reverse_transfer\n if self.status == \"complete\"\n self.receiver.deposit(-self.amount)\n self.sender.deposit(self.amount)\n self.status = \"reversed\"\n end\n end",
"def execute_transaction\n if self.valid? == true && status != \"complete\"\n self.receiver.balance += self.amount\n self.sender.balance -= self.amount\n self.status = \"complete\"\n else\n self.status = \"rejected\"\n return \"Transaction rejected. Please check your account balance.\"\n end\n end",
"def subtract_amount(amount)\n @balance -= amount\n end",
"def calculate_total_payment\n\t\tif self.total_amount.blank?\n\t\t\tbalance = 0\n\t\telse\n\t\t\tbalance = (self.total_amount + self.penalty) - paid_total\n\t\tend\n\n\t\tif balance <= 0\n return 0\n else\n return balance\n end\n\tend",
"def eth_pendingTransactions()\r\n response = do_request(\"eth_pendingTransactions\")\r\n response[\"result\"]\r\n end",
"def balance\n @balance ||= total - amount_paid\n end",
"def execute_transaction\n if valid? && sender.balance > amount && self.status == \"pending\"\n sender.balance -= amount\n receiver.balance += amount\n self.status = \"complete\"\n else\n reject_transfer\n end\n\n end",
"def balance\n\t\tbalance = 0.00\n\t\[email protected] do |transaction|\n\t\t\tbalance += transaction[:amount]\n\t\tend\t\n\n\t\treturn balance\n\tend",
"def end_transaction(result = nil)\n agent&.end_transaction(result)\n end",
"def outstanding_balance\n loan.funded_amount - loan.payments.amount\n end",
"def calculate\n=begin\n self.net_amount = nil\n self.tax_amount = nil\n self.gross_amount = nil\n=end\n self.total\n end",
"def last_operation_time\n last_operation['time'].to_i\n end",
"def total_balance\n return @checking_account_balance + @saving_account_balance\n end",
"def amount\n @amount ||= begin\n amount = Txaction.calculate_amount(params[:amount]).to_d.abs\n amount = -amount if params[:amount_type] == 'spent'\n amount\n end\n end",
"def calculate_current_balance\n if transactionmode == \"Credit\"\n savingsdeposit.current_balance += self.transaction_amount.to_i\n elsif transactionmode == \"Debit\"\n savingsdeposit.current_balance -= self.transaction_amount.to_i\n else\n :savingsdeposits\n end\n savingsdeposit.save\n\nend",
"def balance\n txns.inject(Amount::ZERO) { |sum, t| sum + t.amount }\n end",
"def select_last\n select(@data.index(@event.tb_unit.last_item.object) || 0)\n end",
"def amount_remaining\n @desired_amount - @bought_amount\n end",
"def last\n if @total > 0\n result = {\"elapsed\" => (Time.now - @last_start_time).to_i}\n result[\"type\"] = @last_type if @last_type\n result[\"active\"] = @last_id != 0 if !@last_id.nil?\n result\n end\n end",
"def deposit(t)\n\n @balance += t.amount\n t.currBalance = @balance\n @ledger << t\n\n end",
"def base_tx_finalizers\n tx_id = threadlocal_graph_info[:tx_id] = rand\n commit = ->(reopen = true) do\n if tx_id != threadlocal_graph_info[:tx_id]\n fail InternalError, 'Can not commit transaction outside its original block'\n end\n puts \"transaction committed\" if Pacer.verbose == :very\n blueprints_graph.commit\n # reopen arg is ignored for graphs that automatically open their tx.\n reopen_read_transaction\n on_commit_block.call if on_commit_block\n end\n rollback = ->(message = nil) do\n puts [\"transaction rolled back\", message].compact.join(': ') if Pacer.verbose == :very\n blueprints_graph.rollback\n reopen_read_transaction\n end\n [commit, rollback]\n end"
] | [
"0.88955647",
"0.8789714",
"0.8789714",
"0.8789714",
"0.8662823",
"0.8505989",
"0.8334916",
"0.828992",
"0.8222375",
"0.8113807",
"0.7971079",
"0.7955742",
"0.7713947",
"0.76934713",
"0.7257942",
"0.63174844",
"0.62684506",
"0.6005022",
"0.5990571",
"0.59840107",
"0.5886206",
"0.58063304",
"0.56183857",
"0.5603079",
"0.5595661",
"0.5591449",
"0.5589932",
"0.5573614",
"0.5573068",
"0.55684805",
"0.55645245",
"0.5564031",
"0.5552595",
"0.5549164",
"0.5546057",
"0.5532086",
"0.552378",
"0.5516548",
"0.5499931",
"0.54850364",
"0.54746467",
"0.5468186",
"0.54599464",
"0.5454901",
"0.5454891",
"0.54496974",
"0.5441282",
"0.5429518",
"0.5419733",
"0.5400796",
"0.5399571",
"0.5396605",
"0.5390063",
"0.5388772",
"0.5382822",
"0.5376694",
"0.53737557",
"0.53666055",
"0.5364537",
"0.53486806",
"0.5348074",
"0.53460854",
"0.5341281",
"0.5294413",
"0.5291714",
"0.52912545",
"0.52908313",
"0.5283726",
"0.5278634",
"0.52739614",
"0.5273309",
"0.5272497",
"0.52708346",
"0.52667314",
"0.52543336",
"0.52535284",
"0.52343124",
"0.52338105",
"0.52283514",
"0.5218733",
"0.5217562",
"0.52162564",
"0.52158713",
"0.52142775",
"0.52088827",
"0.5206377",
"0.52058285",
"0.5202352",
"0.5196099",
"0.5196",
"0.519425",
"0.5187995",
"0.518293",
"0.5178093",
"0.517548",
"0.51733863",
"0.5171493",
"0.5159314",
"0.5157802",
"0.51566947"
] | 0.84848934 | 6 |
GET /foo91s or /foo91s.json | def index
@foo91s = Foo91.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(path, **args); end",
"def GET; end",
"def list_active_aos_versions(args = {}) \n get(\"/aosversions.json/\", args)\nend",
"def list_all_aos_versions(args = {}) \n get(\"/aosversions.json/all\", args)\nend",
"def http( *args )\n p http_get( *args )\n end",
"def get_aos_version_by_name(args = {}) \n get(\"/aosversions.json/version/#{args[:aosVersionName]}\", args)\nend",
"def get(url); end",
"def view_api\n api_string = RestClient.get(\"https://itunes.apple.com/search?term=star+wars&entity=song&attribute=movieTerm\")\n api_hash = JSON.parse(api_string)\n\n end",
"def json_get(url)\n get url, :parse=>true\n end",
"def index\n @gets = Get.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gets }\n end\n end",
"def http_method\n :get\n end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def get(route='', params = {}, filter = nil)\n url = base_url + route\n unless filter.nil?\n url << '/' + \"(#{ERB::Util.url_encode(filter)})\"\n end\n url << '.json'\n begin\n JSON.parse(RestClient.get(url, params: params))\n rescue RestClient::ResourceNotFound => e\n Object.new\n end\n end",
"def get(path, params={})\n params = merge_set_up_params(params)\n @token = \"b3688c52-9235-45ca-b01f-c5b2b83a4f4f\"\n @result = Typhoeus::Request.get(API_URL + path, :params => params,\n :headers => {\"Authorization\" => \"Basic#{@token}\"})\n puts @result.body\n # check if the url looks correct in the log\n puts @result.effective_url\n # parse the result to json\n return JSON.parse(@result.body)\n end",
"def to_get_request\n 'get_%ss' % api_name\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n puts JSON.pretty_generate(result)\n result\nend",
"def room_descriptions_method\r\n my_port = 8081\r\n htttproomnumber = $roomnumber\r\n roomsNtext = \"/#{htttproomnumber}\"\r\n rooms_message = \"/rooms#{roomsNtext}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{rooms_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n return my_json[\"room\"].to_s\r\nend",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def get_aos_version(args = {}) \n get(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def hit\n action = params[:req]\n name = params[:name] || params[:id]\n render api_not_supported action, name\n end",
"def show\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foo }\n end\n end",
"def get(*args)\n params = args.extract_options!\n @connection.get do |req|\n req.url versioned_path(args), params\n end\n end",
"def list\n get('/')\n end",
"def request(args = {})\n response = @client.get(args[:url],\n argument_hash(args[:args] || {},\n args[:symbols] || []))\n JSON.parse(response.body)\n end",
"def http_get(path, query, format = :json)\n uri = URI.parse(\"http://#{Jamendo::API_SERVER}/v#{Jamendo::API_VERSION}/#{path}#{query}\")\n puts uri.request_uri\n http = Net::HTTP.new(uri.host, uri.port) \n request = Net::HTTP::Get.new(uri.request_uri)\n begin\n response = http.request(request)\n result = parse_response(response)\n assert_response(result[:headers])\n return result[:results]\n rescue JamendoError => e\n e.inspect\n end\n end",
"def list_tenants_for_circles(args = {}) \n get(\"/tenants.json/circles\", args)\nend",
"def json_get(path, params={})\n json_request(:get, path, params)\n end",
"def api_call(path:, query:)\n url = \"http://api.openweathermap.org#{path}\"\n query[:appid] = @api_key\n json = get_json(url: url, query: query)\n raise Error, 'Invalid API response' if json['cod'].blank?\n raise NotFound, json['message'] if json['cod'].to_i == 404\n raise Error, json['message'] if json['cod'].to_i != 200\n json\n end",
"def get_all_movies_for_actor(actor)\n url = \"http://movies.api.mks.io/movies\"\n response = RestClient.get(url, accept: 'application/json')\n\nend",
"def _api\n res = TinyURL.pack(request[:turl]) if request[:turl]\n res = TinyURL.unpack(request[:url].split('/').last) if request[:url]\n res = TinyURL.count(request[:hits].split('/').last).to_s if request[:hits]\n res ||= ''\n respond res\n end",
"def api_get(path, params = {})\n api_request(:get, path, :params => params)\n end",
"def get endpoint\n do_request :get, endpoint\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def rest_get(url)\n JSON.parse(RestClient.get(url))\n end",
"def get(path, options={})\n http_verb :get, path, options\n end",
"def get; end",
"def get(path, data={})\n http_verb :get, path, data\n end",
"def api_get url_suffix\n url = URI::encode \"#{@@oauth_info[:api_url]}/gems/#{url_suffix}\"\n data = {:client_id => @@oauth_info[:client_id]}\n headers = {:Authorization => \"Bearer #{@access_token}\"}\n\n conn = get_conn url\n #Try request 3 times\n for i in 1..3\n res = conn.get(url, data, headers)\n if res.status == 200 then return JSON.parse(res.body) end\n sleep 1\n end\n raise OAuthSessionError, \"GET Failed. Status: #{res.status}. Body: #{res.body}\"\n end",
"def get(path)\n request 'GET', path\n end",
"def lws_api_get(path)\n # See also catalog_controller for use of ENV['LWS_...']\n url ||= ENV['LWS_API_URL']\n url ||= \"#{ENV['LWS_CORE_URL']}/api\" if ENV['LWS_CORE_URL']\n \n # http://localhost:8888/api/collections\n resp = Net::HTTP.get_response(URI.parse(\"#{url || 'http://127.0.0.1:8888/api'}#{path}\"))\n result = JSON.parse(resp.body)\n end",
"def get_json(path)\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n #puts \"🤖 GET #{path}\"\n #puts \"HTTP #{response.code}\"\n #puts JSON.pretty_generate(result)\n result\nend",
"def http_query(verb, uri, opts)\n JSON.parse RestClient.send(verb, uri.to_s, opts)\n end",
"def get(resource, **params)\n\n execute(Net::HTTP::Get, 'GET', resource, **params)\n\n end",
"def old_rest path, query={}, opts={}, &cb\n get(\"method/#{path}\", {:format => 'json'}.merge(query),\n {:site => old_site}.merge(opts), &cb)\n end",
"def do_GET req, res\n req.path.sub!(/\\A#{Regexp.escape @mount_path}/, '') if @mount_path\n\n case req.path\n when '/' then\n root req, res\n when '/js/darkfish.js', '/js/jquery.js', '/js/search.js',\n %r%^/css/%, %r%^/images/%, %r%^/fonts/% then\n asset :darkfish, req, res\n when '/js/navigation.js', '/js/searcher.js' then\n asset :json_index, req, res\n when '/js/search_index.js' then\n root_search req, res\n else\n show_documentation req, res\n end\n rescue WEBrick::HTTPStatus::NotFound => e\n generator = generator_for RDoc::Store.new\n\n not_found generator, req, res, e.message\n rescue WEBrick::HTTPStatus::Status\n raise\n rescue => e\n error e, req, res\n end",
"def get_some_room_stuff(roomnumberone,pos)\r\n my_port = 8083\r\n room_map_message = \"/maps/#{roomnumberone}/#{pos}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{room_map_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n if my_json[\"east\"]\r\n return my_json[\"east\"]\r\n \r\n elsif my_json[\"west\"]\r\n return my_json[\"west\"]\r\n\r\n elsif my_json[\"north\"]\r\n return my_json[\"north\"]\r\n\r\n elsif my_json[\"contents\"]\r\n return my_json[\"contents\"]\r\n\r\n elsif my_json[\"south\"]\r\n return my_json[\"south\"]\r\n\r\n elsif my_json[\"down\"]\r\n return my_json[\"down\"]\r\n\r\n elsif my_json[\"up\"]\r\n return my_json[\"up\"] \r\n end\r\nend",
"def index\n get('')\n end",
"def get(path)\n request = Net::HTTP::Get.new @uri.path+'/'+path\n request.basic_auth @api_key, ''\n request['User-Agent'] = USER_AGENT\n response = @https.request request\n JSON.parse response.body\n end",
"def lws_api_get(path)\n options = {headers: solr_headers}\n response = HTTParty.get(\"#{FlareConfig.lws_api_url}#{path}\", options)\n Rails.logger.info(\"RESPONSE CODE: #{response.code}\")\n if response.code == 200\n result = JSON.parse(response.body)\n else\n nil\n end\n end",
"def index\n base_url = 'https://www.googleapis.com/books/v1/volumes?q=fiction&maxResults=20'\n and_key = '&key='\n key = ENV['GOOGLE_BOOKS_API_KEY'] \n googleurl = base_url + and_key + key\n\n response = RestClient.get(googleurl)\n @books = JSON.parse(response)\n\n respond_to do |format|\n format.html\n format.json { render json: @books }\n end\n\nend",
"def api_fetch(url)\n JSON.parse(RestClient.get url)\nend",
"def _get\n http_method(:get)\n end",
"def list_all_shards(args = {}) \n get(\"/shards.json/\", args)\nend",
"def test_read_all_info\n get '/v1/read_all?data=eyJOYW1lIjogIkVkdWFyZG8iLCAiQ291bnRyeSI6ICJCcmF6aWwiIH0%3D'\n assert last_response.ok?\n assert last_response.body.include?('Eduardo')\n assert last_response.body.include?('Brazil')\n end",
"def http_get(path)\n http_methods(path, :get)\n end",
"def test\n get(\"/help/test.json\")\n end",
"def test\n get(\"/help/test.json\")\n end",
"def do_get(path, params={})\n login if need_login?\n\n # Resource id is a special param as it needs to be added to the path\n path = add_id_and_params_to_path(path, params)\n\n req, res, resource_type, body = nil\n\n begin\n retry_request(true) do\n # Return content type so the resulting resource object knows what kind of resource it is.\n resource_type, body = @rest_client[path].get(headers) do |response, request, result, &block|\n req, res = request, response\n update_cookies(response)\n update_last_request(request, response)\n\n case response.code\n when 200\n # Get the resource_type from the content_type, the resource_type\n # will be used later to add relevant methods to relevant resources\n type = if result.content_type.index('rightscale')\n get_resource_type(result.content_type)\n elsif result.content_type.index('text/plain')\n 'text'\n else\n ''\n end\n\n # work around getting ASCII-8BIT from some resources like audit entry detail\n charset = get_charset(response.headers)\n if charset && response.body.encoding != charset\n response.body.force_encoding(charset)\n end\n\n # raise an error if the API is misbehaving and returning an empty response when it shouldn't\n if type != 'text' && response.body.empty?\n raise EmptyBodyError.new(request, response)\n end\n\n [type, response.body]\n when 301, 302\n update_api_url(response)\n response.follow_redirection(request, result, &block)\n when 404\n raise UnknownRouteError.new(request, response)\n else\n raise ApiError.new(request, response)\n end\n end\n end\n rescue => e\n raise wrap(e, :get, path, params, req, res)\n end\n\n data = if resource_type == 'text'\n { 'text' => body }\n else\n JSON.parse(body, :allow_nan => true)\n end\n\n [resource_type, path, data]\n end",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def get!\n request! :get\n end",
"def make_search(url)\n #make the web request\n data = RestClient.get url\n JSON.parse(data)\nend",
"def make_request(search_term)\n JSON.parse(RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"))\nend",
"def results\n raw_input = params[:search].to_s\n formatted_input = raw_input.gsub(\" \", \"+\")\n\n @client = HTTParty.get(\"http://api.shopstyle.com/api/v2/products?pid=uid5001-30368749-95&fts='#{formatted_input}'&offset=0&limit=20\")\n\n render json: @client\n end",
"def get(path, params={}, options={})\n request(:get, api_path(path), params, options)\n end",
"def get(endpoint, url, args, version = 'v1')\n qs = build_qs(args)\n req_url = \"#{url}/api/#{version}/#{endpoint}?#{qs}\"\n\n request(req_url, :GET)\n end",
"def test_read_all_info_without_name\n get '/v1/read_all?data=eyAiQ291bnRyeSI6ICJCcmF6aWwiIH0='\n assert last_response.body.include?('Name field was not found in JSON')\n end",
"def get(path, params={})\n params[:apikey] = self.api_key\n RestClient::Request.execute(\n :method => :get,\n :url => \"#{self.uri}#{path}\",\n :headers => {\n :params => params\n },\n :verify_ssl=> @ssl_verify )\n end",
"def get_api_json\n response_string = RestClient.get('http://www.swapi.co/api/people/')\n JSON.parse(response_string)\nend",
"def get(path)\n request(:get, path, {})\n end",
"def get\n url = prefix + \"get\" + id_param\n return response(url)\n end",
"def get(path, data = {})\n # Allow format override\n format = data.delete(:format) || @format\n # Add parameters to URL query string\n get_params = {\n :method => \"get\", \n :verbose => DEBUG\n }\n get_params[:params] = data unless data.empty?\n # Create GET request\n get = Typhoeus::Request.new(\"#{protocol}#{@server}#{path}\", get_params)\n # Send request\n do_request(get, format, :cache => true)\n end",
"def get(connection, path, args = {})\n host, port = connection_host_and_port(connection)\n\n res = open(\n \"http://#{host}:#{port}#{path}#{to_get_params(args)}\"\n ).read\n puts res if @debug\n\n begin\n res = JSON.parse(res)\n raise res['error'] if res.is_a?(Hash) and res['error']\n return res\n rescue JSON::ParserError => e\n end\n\n res\n end",
"def get_response(resource, query_string)\n config = YAML.load(File.read(\"giantbomb.yaml\"))\n api_key = config['api_key']\n api_base = config['api_base']\n return HTTParty.get(\"#{api_base}/#{resource}/?api_key=#{api_key}&format=json&#{query_string}\")\nend",
"def test_srpm_get_url\n get '/srpm/Sisyphus/glibc/get'\n assert_equal 'http://packages.altlinux.org/ru/Sisyphus/srpms/glibc/get', last_response.location\n assert_equal 301, last_response.status\n\n get '/srpm/Branch51/glibc/get'\n assert_equal 'http://packages.altlinux.org/ru/5.1/srpms/glibc/get', last_response.location\n assert_equal 301, last_response.status\n\n get '/srpm/p5/glibc/get'\n assert_equal 'http://packages.altlinux.org/ru/Platform5/srpms/glibc/get', last_response.location\n assert_equal 301, last_response.status\n\n get '/srpm/Branch41/glibc/get'\n assert_equal 'http://packages.altlinux.org/ru/4.1/srpms/glibc/get', last_response.location\n assert_equal 301, last_response.status\n\n get '/srpm/Branch4/glibc/get'\n assert_equal 'http://packages.altlinux.org/ru/4.0/srpms/glibc/get', last_response.location\n assert_equal 301, last_response.status\n end",
"def get url, params={}, headers={}\n uri = URI.parse(url)\n path = uri.path + \"?\" + query_string(default_params.merge(params))\n response = http(uri.host, uri.port).get(path, default_headers.merge(headers))\n JSON.parse(response.body)\n end",
"def call\n fail(WordpRSS::InvalidURLError.new(\"#{url} is not a valid URL\")) unless url =~ URI::regexp\n\n RestClient.get(url)\n end",
"def get(api, params={})\n url2json(:GET, \"#{@endpoint}#{api}\", params)\n end",
"def getstubjson(title_number)\n uri = URI.parse($STUBJSON)\n http = Net::HTTP.new(uri.host, uri.port)\n request = Net::HTTP::Get.new('/' + title_number)\n request.basic_auth $http_auth_name, $http_auth_password\n response = http.request(request)\n if (response.code != '200') then\n raise \"Error in getting JSON for: \" + title_number\n end\n return response.body\nend",
"def index(**params)\n params.stringify_keys!\n path = nest_path_within_parent(plural_resource_path, params)\n api_request(:get, path, params: params)\n end",
"def index\n @fhir_base_urls = FhirBaseUrl.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @fhir_base_urls }\n end\n end",
"def api_request(city)\n url = \"https://jobs.github.com/positions.json?utf8=%E2%9C%93&description=&location=\"+city\n #Escape and parse URL for proper formatting.\n escaped_url = URI.escape(url)\n parsed_url = URI.parse(escaped_url)\n #Make the HTTP request.\n request = Net::HTTP.get(parsed_url)\n #Parse the JSON response.\n response = JSON.parse(request)\n #Returns all listings for the given city.\n return response\n end",
"def all\n api_get(path)\n end",
"def get(*args)\n prepare_request(:get, args)\n @@client.add(:get, @path, *args)\n end",
"def make_request(search_term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\")\n final_response = JSON.parse(response)\nend",
"def index\n @requests = Request.where(status: -1)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @requests }\n end\n end",
"def get(path)\n # TODO: do more hardening on the path\n if path.include?('covid19')\n request = Net::HTTP::Get.new(path, @headers)\n else\n request = Net::HTTP::Get.new('/v2' + path, @headers)\n end\n send_request(request)\n end",
"def search(params = {})\n @api.get(\"api.json\", params)\n end",
"def get(path, data={})\n request(:get, path, data)\n end",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\nend",
"def index\n #pseudo scope \n if params[:phone] \n @agencies = Agency.find_by_phone(params[:phone]);\n if @agencies \n respond_to do |format|\n format.json { render :json => @agencies }\n format.xml { render :xml => @agencies }\n end \n else\n head :not_found\n end\n else\n # Aqui estoy haciendo que el api responda en mas de 1 formato\n @agencies = Agency.all\n respond_to do |format|\n format.json { render :json => @agencies }\n format.xml { render :xml => @agencies }\n end\n\n end \n end",
"def get(path, data=nil)\n request(:get, path, data)\n end",
"def get_room_stuff(pos)\r\n my_port = 8083\r\n room_map_message = \"/maps/#{$roomnumber}/#{pos}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{room_map_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n if my_json[\"east\"]\r\n return my_json[\"east\"]\r\n \r\n elsif my_json[\"west\"]\r\n return my_json[\"west\"]\r\n\r\n elsif my_json[\"north\"]\r\n return my_json[\"north\"]\r\n\r\n elsif my_json[\"contents\"]\r\n return my_json[\"contents\"]\r\n\r\n elsif my_json[\"south\"]\r\n return my_json[\"south\"]\r\n\r\n elsif my_json[\"down\"]\r\n return my_json[\"down\"]\r\n\r\n elsif my_json[\"up\"]\r\n return my_json[\"up\"] \r\n end\r\nend",
"def get(path, options = {}, &block); add :get, path, options, &block end"
] | [
"0.5870235",
"0.58688706",
"0.58610505",
"0.5745187",
"0.5716675",
"0.5706757",
"0.5673086",
"0.5645496",
"0.563858",
"0.5626887",
"0.5600305",
"0.55972075",
"0.5576869",
"0.5574741",
"0.5556026",
"0.5555883",
"0.5545138",
"0.553712",
"0.5512892",
"0.5512892",
"0.5508374",
"0.550781",
"0.54956615",
"0.5493126",
"0.54824036",
"0.5482249",
"0.5470493",
"0.5460882",
"0.5460718",
"0.5458764",
"0.54561037",
"0.5446302",
"0.54382247",
"0.5437808",
"0.54348415",
"0.54348415",
"0.5429113",
"0.5429113",
"0.5427856",
"0.542543",
"0.54220706",
"0.541667",
"0.5411646",
"0.53946066",
"0.53893685",
"0.53870296",
"0.5376187",
"0.53644943",
"0.53644603",
"0.53609717",
"0.5336264",
"0.53337735",
"0.5331737",
"0.5326785",
"0.5320599",
"0.53179497",
"0.5315768",
"0.53141254",
"0.53095645",
"0.53040266",
"0.5299019",
"0.5299019",
"0.52944154",
"0.52936614",
"0.52936614",
"0.5287588",
"0.5282997",
"0.528144",
"0.5278642",
"0.5267883",
"0.52652746",
"0.52530724",
"0.52440315",
"0.5239507",
"0.52334183",
"0.52329665",
"0.52274585",
"0.5223944",
"0.5220528",
"0.52194786",
"0.52180755",
"0.52135825",
"0.5209958",
"0.52091897",
"0.52016985",
"0.5200847",
"0.51897013",
"0.51893044",
"0.5186996",
"0.5183459",
"0.5178999",
"0.51730156",
"0.51676774",
"0.5161866",
"0.51589817",
"0.51572216",
"0.51546055",
"0.5153184",
"0.5150534",
"0.515031"
] | 0.51883996 | 88 |
GET /foo91s/1 or /foo91s/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_aos_version_by_name(args = {}) \n get(\"/aosversions.json/version/#{args[:aosVersionName]}\", args)\nend",
"def get(path, **args); end",
"def get_aos_version(args = {}) \n get(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def list_active_aos_versions(args = {}) \n get(\"/aosversions.json/\", args)\nend",
"def to_get_request\n 'get_%ss' % api_name\n end",
"def get(path, params={})\n params = merge_set_up_params(params)\n @token = \"b3688c52-9235-45ca-b01f-c5b2b83a4f4f\"\n @result = Typhoeus::Request.get(API_URL + path, :params => params,\n :headers => {\"Authorization\" => \"Basic#{@token}\"})\n puts @result.body\n # check if the url looks correct in the log\n puts @result.effective_url\n # parse the result to json\n return JSON.parse(@result.body)\n end",
"def GET; end",
"def show\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foo }\n end\n end",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n puts JSON.pretty_generate(result)\n result\nend",
"def http( *args )\n p http_get( *args )\n end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def list_all_aos_versions(args = {}) \n get(\"/aosversions.json/all\", args)\nend",
"def http_method\n :get\n end",
"def get\n url = prefix + \"get\" + id_param\n return response(url)\n end",
"def http_get(path, query, format = :json)\n uri = URI.parse(\"http://#{Jamendo::API_SERVER}/v#{Jamendo::API_VERSION}/#{path}#{query}\")\n puts uri.request_uri\n http = Net::HTTP.new(uri.host, uri.port) \n request = Net::HTTP::Get.new(uri.request_uri)\n begin\n response = http.request(request)\n result = parse_response(response)\n assert_response(result[:headers])\n return result[:results]\n rescue JamendoError => e\n e.inspect\n end\n end",
"def view_api\n api_string = RestClient.get(\"https://itunes.apple.com/search?term=star+wars&entity=song&attribute=movieTerm\")\n api_hash = JSON.parse(api_string)\n\n end",
"def room_descriptions_method\r\n my_port = 8081\r\n htttproomnumber = $roomnumber\r\n roomsNtext = \"/#{htttproomnumber}\"\r\n rooms_message = \"/rooms#{roomsNtext}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{rooms_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n return my_json[\"room\"].to_s\r\nend",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get_json(path)\n puts \"*** GET #{path}\"\n\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n puts \"HTTP #{response.code}\"\n\n #puts JSON.pretty_generate(result)\n result\nend",
"def get(*args)\n params = args.extract_options!\n @connection.get do |req|\n req.url versioned_path(args), params\n end\n end",
"def json_get(path, params={})\n json_request(:get, path, params)\n end",
"def hit\n action = params[:req]\n name = params[:name] || params[:id]\n render api_not_supported action, name\n end",
"def get(url); end",
"def api_get(path, params = {})\n api_request(:get, path, :params => params)\n end",
"def json_get(url)\n get url, :parse=>true\n end",
"def get(route='', params = {}, filter = nil)\n url = base_url + route\n unless filter.nil?\n url << '/' + \"(#{ERB::Util.url_encode(filter)})\"\n end\n url << '.json'\n begin\n JSON.parse(RestClient.get(url, params: params))\n rescue RestClient::ResourceNotFound => e\n Object.new\n end\n end",
"def do_get(path, params={})\n login if need_login?\n\n # Resource id is a special param as it needs to be added to the path\n path = add_id_and_params_to_path(path, params)\n\n req, res, resource_type, body = nil\n\n begin\n retry_request(true) do\n # Return content type so the resulting resource object knows what kind of resource it is.\n resource_type, body = @rest_client[path].get(headers) do |response, request, result, &block|\n req, res = request, response\n update_cookies(response)\n update_last_request(request, response)\n\n case response.code\n when 200\n # Get the resource_type from the content_type, the resource_type\n # will be used later to add relevant methods to relevant resources\n type = if result.content_type.index('rightscale')\n get_resource_type(result.content_type)\n elsif result.content_type.index('text/plain')\n 'text'\n else\n ''\n end\n\n # work around getting ASCII-8BIT from some resources like audit entry detail\n charset = get_charset(response.headers)\n if charset && response.body.encoding != charset\n response.body.force_encoding(charset)\n end\n\n # raise an error if the API is misbehaving and returning an empty response when it shouldn't\n if type != 'text' && response.body.empty?\n raise EmptyBodyError.new(request, response)\n end\n\n [type, response.body]\n when 301, 302\n update_api_url(response)\n response.follow_redirection(request, result, &block)\n when 404\n raise UnknownRouteError.new(request, response)\n else\n raise ApiError.new(request, response)\n end\n end\n end\n rescue => e\n raise wrap(e, :get, path, params, req, res)\n end\n\n data = if resource_type == 'text'\n { 'text' => body }\n else\n JSON.parse(body, :allow_nan => true)\n end\n\n [resource_type, path, data]\n end",
"def get_one(*path, query: nil, api_v1: true)\n url = encode_url(path: path, query: query, api_v1: api_v1)\n faraday_safe(:get, url).body\n end",
"def get; end",
"def index\n @gets = Get.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gets }\n end\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get(path)\n request 'GET', path\n end",
"def get(path, options={})\n http_verb :get, path, options\n end",
"def get_json(path)\n response = Net::HTTP.get_response(build_uri(path))\n result = JSON.parse(response.body)\n #puts \"🤖 GET #{path}\"\n #puts \"HTTP #{response.code}\"\n #puts JSON.pretty_generate(result)\n result\nend",
"def get(path, data={})\n http_verb :get, path, data\n end",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def get(path)\n # TODO: do more hardening on the path\n if path.include?('covid19')\n request = Net::HTTP::Get.new(path, @headers)\n else\n request = Net::HTTP::Get.new('/v2' + path, @headers)\n end\n send_request(request)\n end",
"def get(path)\n request = Net::HTTP::Get.new @uri.path+'/'+path\n request.basic_auth @api_key, ''\n request['User-Agent'] = USER_AGENT\n response = @https.request request\n JSON.parse response.body\n end",
"def get_all_movies_for_actor(actor)\n url = \"http://movies.api.mks.io/movies\"\n response = RestClient.get(url, accept: 'application/json')\n\nend",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def show\n client= Client.find_by_id params[:id]\n if client != nil\n render(json: client, status: 200) \n else\n head 404\n end \n end",
"def getstubjson(title_number)\n uri = URI.parse($STUBJSON)\n http = Net::HTTP.new(uri.host, uri.port)\n request = Net::HTTP::Get.new('/' + title_number)\n request.basic_auth $http_auth_name, $http_auth_password\n response = http.request(request)\n if (response.code != '200') then\n raise \"Error in getting JSON for: \" + title_number\n end\n return response.body\nend",
"def api_get url_suffix\n url = URI::encode \"#{@@oauth_info[:api_url]}/gems/#{url_suffix}\"\n data = {:client_id => @@oauth_info[:client_id]}\n headers = {:Authorization => \"Bearer #{@access_token}\"}\n\n conn = get_conn url\n #Try request 3 times\n for i in 1..3\n res = conn.get(url, data, headers)\n if res.status == 200 then return JSON.parse(res.body) end\n sleep 1\n end\n raise OAuthSessionError, \"GET Failed. Status: #{res.status}. Body: #{res.body}\"\n end",
"def get endpoint\n do_request :get, endpoint\n end",
"def get_aos_version_box_by_name(args = {}) \n get(\"/aosversions.json/aosversionbox/name/#{args[:aosVersionBoxName]}\", args)\nend",
"def get(path, params={})\n params[:apikey] = self.api_key\n RestClient::Request.execute(\n :method => :get,\n :url => \"#{self.uri}#{path}\",\n :headers => {\n :params => params\n },\n :verify_ssl=> @ssl_verify )\n end",
"def fetch_version(resource_type,identifier,params={})\n path = '/api/' + resource_type.to_s + '_version?name=' + identifier\n http_get(path,params)\n end",
"def lws_api_get(path)\n # See also catalog_controller for use of ENV['LWS_...']\n url ||= ENV['LWS_API_URL']\n url ||= \"#{ENV['LWS_CORE_URL']}/api\" if ENV['LWS_CORE_URL']\n \n # http://localhost:8888/api/collections\n resp = Net::HTTP.get_response(URI.parse(\"#{url || 'http://127.0.0.1:8888/api'}#{path}\"))\n result = JSON.parse(resp.body)\n end",
"def get(resource, **params)\n\n execute(Net::HTTP::Get, 'GET', resource, **params)\n\n end",
"def rest_get(url)\n JSON.parse(RestClient.get(url))\n end",
"def api_call(path:, query:)\n url = \"http://api.openweathermap.org#{path}\"\n query[:appid] = @api_key\n json = get_json(url: url, query: query)\n raise Error, 'Invalid API response' if json['cod'].blank?\n raise NotFound, json['message'] if json['cod'].to_i == 404\n raise Error, json['message'] if json['cod'].to_i != 200\n json\n end",
"def _get\n http_method(:get)\n end",
"def get(*path, auto_paginate: false, query: nil, api_v1: true)\n get_method = auto_paginate ? :get_all : :get_one\n send(get_method, path, query: query, api_v1: api_v1)\n end",
"def request(args = {})\n response = @client.get(args[:url],\n argument_hash(args[:args] || {},\n args[:symbols] || []))\n JSON.parse(response.body)\n end",
"def test_read_all_info_without_name\n get '/v1/read_all?data=eyAiQ291bnRyeSI6ICJCcmF6aWwiIH0='\n assert last_response.body.include?('Name field was not found in JSON')\n end",
"def api_fetch(url)\n JSON.parse(RestClient.get url)\nend",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def get(path)\n request(:get, path, {})\n end",
"def get(connection, path, args = {})\n host, port = connection_host_and_port(connection)\n\n res = open(\n \"http://#{host}:#{port}#{path}#{to_get_params(args)}\"\n ).read\n puts res if @debug\n\n begin\n res = JSON.parse(res)\n raise res['error'] if res.is_a?(Hash) and res['error']\n return res\n rescue JSON::ParserError => e\n end\n\n res\n end",
"def get(*args)\n prepare_request(:get, args)\n @@client.add(:get, @path, *args)\n end",
"def query_api(path)\n with_http_error_handling do\n res = RestClient.get(endpoint + path)\n h = Hash.from_xml(res.body)\n h[\"response\"]\n end\n end",
"def get!(*args)\n @response = get(*args)\n end",
"def get(path, data = {})\n # Allow format override\n format = data.delete(:format) || @format\n # Add parameters to URL query string\n get_params = {\n :method => \"get\", \n :verbose => DEBUG\n }\n get_params[:params] = data unless data.empty?\n # Create GET request\n get = Typhoeus::Request.new(\"#{protocol}#{@server}#{path}\", get_params)\n # Send request\n do_request(get, format, :cache => true)\n end",
"def get(path, params={}, options={})\n request(:get, api_path(path), params, options)\n end",
"def get_some_room_stuff(roomnumberone,pos)\r\n my_port = 8083\r\n room_map_message = \"/maps/#{roomnumberone}/#{pos}\"\r\n url = URI.parse(\"http://localhost:#{my_port}#{room_map_message}\")\r\n req = Net::HTTP::Get.new(url.to_s)\r\n res = Net::HTTP.start(url.host, url.port){|http|\r\n http.request(req)\r\n }\r\n my_json = JSON.parse(res.body) \r\n if my_json[\"east\"]\r\n return my_json[\"east\"]\r\n \r\n elsif my_json[\"west\"]\r\n return my_json[\"west\"]\r\n\r\n elsif my_json[\"north\"]\r\n return my_json[\"north\"]\r\n\r\n elsif my_json[\"contents\"]\r\n return my_json[\"contents\"]\r\n\r\n elsif my_json[\"south\"]\r\n return my_json[\"south\"]\r\n\r\n elsif my_json[\"down\"]\r\n return my_json[\"down\"]\r\n\r\n elsif my_json[\"up\"]\r\n return my_json[\"up\"] \r\n end\r\nend",
"def get(type, id)\n info = json_get(@target, \"#{type_info(type, :path)}/#{Addressable::URI.encode(id)}\",\n @key_style, headers)\n\n fake_client_id(info) if type == :client # hide client reply, not quite scim\n info\n end",
"def show\n @fhir_base_url = FhirBaseUrl.find(params[:id])\n\n respond_to do |format|\n format.html { redirect_to :action => :edit }\n format.json { render json: @fhir_base_url }\n end\n end",
"def get(endpoint, url, args, version = 'v1')\n qs = build_qs(args)\n req_url = \"#{url}/api/#{version}/#{endpoint}?#{qs}\"\n\n request(req_url, :GET)\n end",
"def get_version\n response = self.class.get(\"/service/#{$service_id}/version/#{$service_version}\", {\n headers: {\"Fastly-Key\" => $key}\n })\n end",
"def get\n if(resource.exist?)\n #print_range(request)\n res = resource.get(request, response)\n if(res == OK && !resource.collection?)\n response['Etag'] = resource.etag\n response['Content-Type'] = resource.content_type\n response['Content-Length'] = resource.content_length.to_s\n response['Last-Modified'] = resource.last_modified.httpdate\n end\n res\n else\n NotFound\n end\n end",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n return JSON.parse(site.get(:accept=>\"application/json\"))\nend",
"def get(path, params={})\n params = merge_set_up_params(params)\n JSON.parse(Typhoeus::Request.get(API_URL + path, :params => params).body)[\"response\"]\n end",
"def get_photos(arg)\n response_str = RestClient.get(\"#{arg}.json\")\n response_hash = JSON.parse(response_str)\n return response_hash\nend",
"def http_query(verb, uri, opts)\n JSON.parse RestClient.send(verb, uri.to_s, opts)\n end",
"def show\n @foo_model = FooModel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foo_model }\n end\n end",
"def test_read_all_info\n get '/v1/read_all?data=eyJOYW1lIjogIkVkdWFyZG8iLCAiQ291bnRyeSI6ICJCcmF6aWwiIH0%3D'\n assert last_response.ok?\n assert last_response.body.include?('Eduardo')\n assert last_response.body.include?('Brazil')\n end",
"def get(path, data={})\n RestClient.get(full_url(path), {params: data})\n rescue RestClient::Exception => error\n message = \"REST client exception caught processing GET request.\"\n log.error \"#{message}\\nCause: #{error}\\n\" +\n error.backtrace.join(\"\\n\")\n raise CAHTTPError.new(message, error, response: error.response, url: full_url(path))\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get\n url = prefix + \"get\"\n return response(url)\n end",
"def get path, header={}, body_string_or_hash=\"\"\n env.http 'GET', path, header, body_string_or_hash\n end",
"def index\n base_url = 'https://www.googleapis.com/books/v1/volumes?q=fiction&maxResults=20'\n and_key = '&key='\n key = ENV['GOOGLE_BOOKS_API_KEY'] \n googleurl = base_url + and_key + key\n\n response = RestClient.get(googleurl)\n @books = JSON.parse(response)\n\n respond_to do |format|\n format.html\n format.json { render json: @books }\n end\n\nend",
"def lws_api_get(path)\n options = {headers: solr_headers}\n response = HTTParty.get(\"#{FlareConfig.lws_api_url}#{path}\", options)\n Rails.logger.info(\"RESPONSE CODE: #{response.code}\")\n if response.code == 200\n result = JSON.parse(response.body)\n else\n nil\n end\n end",
"def get(path)\n response = Excon.get(\n 'https://' + @host + '/' + path + '.json?print=pretty',\n headers: {\n 'x-rapidapi-host' => @host,\n 'x-rapidapi-key' => @key,\n }\n )\n\n return false if response.status != 200\n\n JSON.parse(response.body)\n end",
"def _api\n res = TinyURL.pack(request[:turl]) if request[:turl]\n res = TinyURL.unpack(request[:url].split('/').last) if request[:url]\n res = TinyURL.count(request[:hits].split('/').last).to_s if request[:hits]\n res ||= ''\n respond res\n end",
"def get(path='/')\n `curl -sf http://localhost:3234#{path}`\n end",
"def get(path, params={})\n RestClient.get request_base+path, {params: params}\n end",
"def fetch(resource,identifier,params={})\n uri = '/api/' + resource.to_s + '/' + identifier\n http_get(uri,params)\n end",
"def show\n respond_to do |format|\n format.json { render :show, status: :ok, location: @api_v1_contract }\n end\n end",
"def make_request(search_term)\n JSON.parse(RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{search_term}\"))\nend",
"def fetch_books(term)\n response = RestClient.get(\"https://www.googleapis.com/books/v1/volumes?q=#{term}\")\n\n JSON.parse(response.body)\nend",
"def get(path, data={})\n request(:get, path, data)\n end",
"def index\n get('')\n end",
"def get path = \"\", payload = {}\n make_request(path, \"get\", payload)\n end",
"def get!\n request! :get\n end",
"def old_rest path, query={}, opts={}, &cb\n get(\"method/#{path}\", {:format => 'json'}.merge(query),\n {:site => old_site}.merge(opts), &cb)\n end",
"def get url, options={}\n options.merge!({:v => Time.now.strftime(\"%Y%m%d\")}) unless options[:v]\n response = self.class.get(url, {:query => options}).parsed_response\n if response[\"meta\"][\"code\"] == 200\n return response\n else\n raise Foursquared::Error.new(response[\"meta\"])\n end\n end",
"def get\n start { |connection| connection.request http :Get }\n end",
"def get_response(resource, query_string)\n config = YAML.load(File.read(\"giantbomb.yaml\"))\n api_key = config['api_key']\n api_base = config['api_base']\n return HTTParty.get(\"#{api_base}/#{resource}/?api_key=#{api_key}&format=json&#{query_string}\")\nend"
] | [
"0.60760486",
"0.6040446",
"0.593873",
"0.59266245",
"0.58210444",
"0.5770206",
"0.5726346",
"0.5718768",
"0.5706767",
"0.5691218",
"0.5673726",
"0.56736785",
"0.5626185",
"0.56199014",
"0.5615353",
"0.5606875",
"0.56060904",
"0.56053865",
"0.56053865",
"0.5604031",
"0.5601622",
"0.5590082",
"0.55865633",
"0.55760294",
"0.55563253",
"0.55554414",
"0.55536115",
"0.5553553",
"0.5536091",
"0.5523033",
"0.5521722",
"0.5521722",
"0.5521552",
"0.5513109",
"0.55112886",
"0.55085504",
"0.5500651",
"0.5500651",
"0.5487729",
"0.5483925",
"0.54735374",
"0.5471551",
"0.54710454",
"0.54686403",
"0.54675096",
"0.5461024",
"0.54572165",
"0.5448632",
"0.5445788",
"0.54451",
"0.5444906",
"0.54278225",
"0.54236245",
"0.5419488",
"0.5412361",
"0.54064184",
"0.5400387",
"0.5397836",
"0.53944063",
"0.5393874",
"0.53860205",
"0.53857166",
"0.53716",
"0.5366405",
"0.53641105",
"0.53617454",
"0.5352104",
"0.5348245",
"0.5345637",
"0.5344401",
"0.53389204",
"0.53360075",
"0.5333544",
"0.5333544",
"0.5329895",
"0.5327205",
"0.5317336",
"0.53154796",
"0.5314719",
"0.5308308",
"0.5307424",
"0.5307424",
"0.5303035",
"0.53006434",
"0.5292616",
"0.52923435",
"0.5287421",
"0.52852756",
"0.5276677",
"0.5276609",
"0.5275965",
"0.52725106",
"0.52674854",
"0.5263915",
"0.5260999",
"0.52539647",
"0.5249876",
"0.52458286",
"0.5243974",
"0.5242005",
"0.5241018"
] | 0.0 | -1 |
POST /foo91s or /foo91s.json | def create
@foo91 = Foo91.new(foo91_params)
respond_to do |format|
if @foo91.save
format.html { redirect_to @foo91, notice: "Foo91 was successfully created." }
format.json { render :show, status: :created, location: @foo91 }
else
format.html { render :new, status: :unprocessable_entity }
format.json { render json: @foo91.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(path, **args); end",
"def post_json(path, body)\n uri = build_uri(path)\n puts \"*** POST #{path}\"\n puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n puts JSON.pretty_generate(result)\n result\nend",
"def create(url, data)\n RestClient.post ENV['APIBASE']+url, data, :content_type => :json\nend",
"def post(path, data = {})\n request 'POST', path, body: data.to_json\n end",
"def post(path, body = nil, ctype = 'text/plain')\n body = body.to_json unless body.is_a?(String)\n make_call(mk_conn(path, 'Content-Type': ctype,\n 'Accept': 'application/json'),\n :post, nil, body)\n end",
"def post_api(path, params={}, headers={})\n headers.merge!('CONTENT_TYPE' => \"application/json\")\n post path, params, headers\nend",
"def post_json(path, body)\n uri = build_uri(path)\n puts \"*** POST #{path}\"\n puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n puts result[:result]\n result\nend",
"def post endpoint, data\n do_request :post, endpoint, data\n end",
"def post_json(path, body)\n uri = build_uri(path)\n puts \"*** POST #{uri}\"\n puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n puts result[:result]\n result\nend",
"def http_post(path, request)\n @http.post(\n :body => JSON(:request => request.to_hash),\n :headers => headers,\n :path => \"/api/v2/#{path}\",\n :expects => [200, 201, 202]\n )\n end",
"def api_gateway_post(path, params)\n api_gateway_body_fwd = params.to_json\n rack_input = StringIO.new(api_gateway_body_fwd)\n\n post path, real_params = {}, 'rack.input' => rack_input\nend",
"def api_gateway_post(path, params)\n api_gateway_body_fwd = params.to_json\n rack_input = StringIO.new(api_gateway_body_fwd)\n\n post path, real_params = {}, {\"rack.input\" => rack_input}\nend",
"def post_json(path, body)\n uri = build_uri(path)\n #puts \"🤖 POST #{path}\"\n #puts JSON.pretty_generate(body)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n #puts \"HTTP #{response.code}\"\n result = JSON.parse(response.body)\n #puts result[:result]\n result\nend",
"def api_post(path, data = {})\n api_request(:post, path, :data => data)\n end",
"def api_post(action, data)\n api_request(action, data, 'POST')\n end",
"def post payload, path = \"\" \n make_request(path, \"post\", payload)\n end",
"def http_post(path, data, content_type = 'application/json')\n http_methods(path, :post, data, content_type)\n end",
"def post operation, data={}\n body = case data\n when String\n body = data\n else\n Yajl::Encoder.encode(data)\n end\n\n request = new_request operation, body\n request.sign sts\n hydra.queue request\n hydra.run\n response = request.response\n puts response.inspect if @debug\n\n if response.code == 200\n Yajl::Parser.parse response.body\n else\n raise_error response\n end\n end",
"def post_json(path, body)\n uri = build_uri(path)\n\n post_request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')\n post_request.body = JSON.generate(body)\n\n response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => true) do |http|\n http.request(post_request)\n end\n\n result = JSON.parse(response.body)\n puts result\n result\nend",
"def post(path, json, params = {})\n if path.include?('covid19')\n request = Net::HTTP::Post.new(path, @headers)\n else\n request = Net::HTTP::Post.new('/v2' + path, @headers)\n end\n request.add_field('Content-Type', 'application/json')\n request.body = json\n params.each do |k, v|\n request[k] = v\n end\n send_request(request)\n end",
"def POST; end",
"def post_rest_api(endpoint, data, http)\n rest_api_endpoint = \"/classifier-api/v1/#{endpoint}\"\n\n # Create an HTTP POST request against the specified REST API endpoint\n request = Net::HTTP::Post.new(rest_api_endpoint)\n # Set the Content-Type and data of the HTTP POST request\n request.content_type = \"application/json\"\n request.body = data\n # Submit the request\n response = http.request(request)\n # Return the response bosy (JSON containing the result of the POST operation)\n response.body\nend",
"def api_post(action, data, binary_key = nil)\n api_request(action, data, 'POST', binary_key)\n end",
"def post(data = {})\n call data, method: :post\n end",
"def post(*args)\n request :post, *args\n end",
"def post(path, options={})\n request :post, path, options\n end",
"def post!\n request! :post\n end",
"def post(path, params={})\n RestClient.post request_base+path, params\n end",
"def create_recipe_request(version, auth_headers, data = {})\n post \"/api/recipes\", params: data, headers: {'Content-Type' => \"application/json\", 'Accept' => \"application/vnd.ink.#{version}\" }.merge(auth_headers)\nend",
"def post(path, data={})\n request(:post, path, data)\n end",
"def add_aos_version(args = {}) \n post(\"/aosversions.json/\", args)\nend",
"def post(json)\n with_endpoint do |endpoint|\n url = [endpoint, @resource_name].compact.join('/')\n url += \"/\"\n return HTTParty.post(url, :body => json, :timeout => 4, :headers => { 'Content-Type' => 'application/json' })\n end\n end",
"def http_post(uri, data)\n RestClient.post uri, data\n end",
"def post_check(excon, body)\n excon.request(\n method: :post,\n path: '/check',\n headers: { 'Content-Type' => 'application/json' },\n body: body\n )\nend",
"def handle_post()\n make_response(201, \"New resource created\")\nend",
"def post(action, **args); end",
"def create\n @foo81 = Foo81.new(foo81_params)\n\n respond_to do |format|\n if @foo81.save\n format.html { redirect_to @foo81, notice: \"Foo81 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo81 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(resource:, data:, version: :v1)\n if data.is_a? String\n begin\n MultiJson.load data\n rescue MultiJson::ParseError => e\n raise BayPhoto::Exceptions::BadJSON, \"Invalid JSON string: #{e.message}\"\n end\n else\n data = MultiJson.dump data\n end\n\n handle = http_handle(version: version)\n\n req = Net::HTTP::Post.new(uri_path_for(resource: resource, version: version))\n req[\"Content-Type\"] = \"application/json\"\n SET_REQUEST_AUTH_TOKEN.call(req)\n req.body = data\n\n handle_response(handle.request(req))\n end",
"def post(path, params={}, options={})\n request(:post, api_path(path), params, options)\n end",
"def post(*args)\n super(*wrap_for_json_api(*args))\n end",
"def post(path, data, params = {}, request_options = {})\n request(:post, path, data, params)\n end",
"def post(resource, params)\n case resource\n when \"pedidos\", \"place_order\", \"new_order\" then url = \"/pedidos\"\n when \"envios\", \"shipping\" then url = \"/envios\"\n else url = \"/#{resource}\"\n end\n\n post_request(url, params)\n end",
"def post(*args)\n request(:post, *args)\n end",
"def post(path, data=nil)\n request(:post, path, data)\n end",
"def post(path, params={})\n params[:apikey] = self.api_key\n RestClient::Request.execute(\n :method => :post,\n :url => \"#{self.uri}#{path}\",\n :headers=> {},\n :payload=> params,\n :verify_ssl=> @ssl_verify )\n end",
"def post(path, params = {})\n resource(path).post(params)\n end",
"def post(api, params)\n url2json(:POST, \"#{@endpoint}#{api}\", params)\n end",
"def post(uri, options = T.unsafe(nil)); end",
"def post(path, body = nil, options={})\n options[\"format\"] = \"json\"\n connection.post do |request|\n request.url URI.encode(path)\n request.params.merge! options\n request.body = body if body\n end\n end",
"def post(path, params={})\n request(:post, path, params)\n end",
"def post(path, params={})\n request(:post, path, params)\n end",
"def post(path, params={})\n request(:post, path, params)\n end",
"def post(path, data = {}, params = {})\n body = data.to_json\n path = File.join(@prefix, path)\n\n response = @conn.post(path, body) do |req|\n req.params = params\n req.headers['Content-Type'] = 'application/json'\n end\n\n JSON.parse response.body\n end",
"def create\n @foo83 = Foo83.new(foo83_params)\n\n respond_to do |format|\n if @foo83.save\n format.html { redirect_to @foo83, notice: \"Foo83 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo83 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, params = nil)\n response = @connection.post do |req|\n req.headers = generate_headers\n req.url path\n req.body = params.to_json\n end\n Arke::Log.fatal(build_error(response)) if response.env.status != 201\n response\n end",
"def create\n @foo93 = Foo93.new(foo93_params)\n\n respond_to do |format|\n if @foo93.save\n format.html { redirect_to @foo93, notice: \"Foo93 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo93 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo93.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, params = {})\n\t\trequest(path, :post, params)\n\tend",
"def post(endpoint, url, args, version = 'v1')\n qs = build_qs(args)\n req_url = \"#{url}/api/#{version}/#{endpoint}?#{qs}\"\n\n request(req_url, :POST)\n end",
"def post; end",
"def data_to_api(snack_name, snack_location, snack_optional)\n RestClient.post ENV['NERDERY_API'], { name: snack_name,\n location: snack_location,\n optional: snack_optional\n }.to_json, content_type: :json\n end",
"def post\n resource.post(request, response)\n end",
"def post_json(location, json_data)\n response = RestClient::Request.new(\n :method => :post,\n :url => location,\n :user => $username,\n :password => $password,\n :headers => { :accept => :json,\n :content_type => :json},\n :payload => json_data\n ).execute\n results = JSON.parse(response.to_str)\n end",
"def post_json(location, json_data)\n response = RestClient::Request.new(\n :method => :post,\n :url => location,\n :user => $username,\n :password => $password,\n :headers => { :accept => :json,\n :content_type => :json},\n :payload => json_data\n ).execute\n results = JSON.parse(response.to_str)\n end",
"def post(request)\n # sure thing!\n json_response(200, { message: \"This dummy POST endpoint didn't do anything.\" })\n end",
"def handle_post\n make_response(201, {message: 'New resource created'})\nend",
"def create\n @foo78 = Foo78.new(foo78_params)\n\n respond_to do |format|\n if @foo78.save\n format.html { redirect_to @foo78, notice: \"Foo78 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo78 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo78.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foo56 = Foo56.new(foo56_params)\n\n respond_to do |format|\n if @foo56.save\n format.html { redirect_to @foo56, notice: \"Foo56 was successfully created.\" }\n format.json { render :show, status: :created, location: @foo56 }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @foo56.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, options = {})\n nonce, signature = generate_signature\n options = options.merge(key: @api_key, nonce: nonce, signature: signature)\n result = @connection.post(\"#{path}/\", options).body\n JSON.parse(result)\n end",
"def call method, args = {}\n unless args.is_a? Hash\n raise ArgumentError.new \"argument must be a Hash\"\n end\n\n args.each_key do |key|\n if args[key].is_a?(Array) || args[key].is_a?(Hash)\n args[key] = JSON.dump(args[key])\n end\n end\n\n @faraday.post method, args\n end",
"def post_spoonacular\n # %encode ingredients to url\n encoded_ingr = URI.escape(@translated_recipe[:ingredients_list])\n # post call block :\n url = URI(\"https://spoonacular-recipe-food-nutrition-v1.p.rapidapi.com/recipes/parseIngredients?includeNutrition=true\")\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Post.new(url)\n request[\"content-type\"] = \"application/x-www-form-urlencoded\"\n request[\"x-rapidapi-key\"] = ENV[\"X_RAPIDAPI_KEY\"]\n request[\"x-rapidapi-host\"] = \"spoonacular-recipe-food-nutrition-v1.p.rapidapi.com\"\n # body of the call with ingredients and servings\n request.body = \"ingredientList=#{encoded_ingr}&#{@recipe_hash[:servings]}\"\n # response\n response = http.request(request)\n end",
"def post(path, params={})\n signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params\n request(:post, path, params, signature_params)\n end",
"def post(path, params={})\n signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params\n request(:post, path, params, signature_params)\n end",
"def post(path, params={})\n signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params\n request(:post, path, params, signature_params)\n end",
"def post(path, params={})\n signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params\n request(:post, path, params, signature_params)\n end",
"def post(path, *data, &block)\n map(path, R3::POST, *data, &block)\n end",
"def post(path, params={})\n signature_params = params.values.any?{|value| value.respond_to?(:to_io)} ? {} : params\n request(:post, path, params, signature_params)\n end",
"def post(path, payload={})\n request(:post, path, payload)\n end",
"def create_post(params)\n mock_request = Rack::MockRequest.new(APP)\n mock_request.post(new_post_endpoint, { 'router.params' => params, format: :json })\n end",
"def post(resource, **params)\n\n execute(Net::HTTP::Post, 'POST', resource, **params)\n\n end",
"def post(url, resource_name, options = {})\n build_response(resource_name) do\n connection.post do |req|\n req.url url\n req.body = options.to_json\n end\n end\n end",
"def post(action, params = T.unsafe(nil), header = T.unsafe(nil), query = T.unsafe(nil)); end",
"def post(path, **options)\n execute :post, path, options\n end",
"def post(path, options = {})\n request(:post, path, options)\n end",
"def post(path, options = {})\n request(:post, path, options)\n end",
"def post(path, options = {})\n request(:post, path, options)\n end",
"def post(path, form_data=nil)\n parse_json do |parser|\n @http_client.post(path, form_data) {|chunk| parser << chunk }\n end\n end",
"def post(path, options={}, format=format)\n request(:post, path, options, format)\n end",
"def post(path, params = {})\n signature_params = params.values.any? { |value| value.respond_to?(:to_io) } ? {} : params\n request(:post, path, params, signature_params)\n end",
"def update(url, data)\n RestClient.put url, data, :content_type => :json\nend",
"def post(path, params = {})\n request(:post, path, params)\n end",
"def post(path, params)\n request(:post, path, params)\n end",
"def post\n Typhoeus.post(@url,\n body: @results_hash.to_json,\n headers: { 'Content-Type' => 'application/json' })\n end",
"def test_should_create_post_via_API_JSON\r\n get \"/logout\"\r\n post \"/forum_posts.json\", :api_key=>'testapikey',\r\n :forum_post => {:title=>'API Test Post',\r\n :body=>'Test Post desc',\r\n :user_id=>1}\r\n assert_response :created\r\n topic = JSON.parse(response.body)\r\n assert topic['title'] == 'API Test Post', 'Incorrect topic title'\r\n assert topic['user_id'] == 1, 'Incorrect user id'\r\n assert topic['body'] == 'Test Post desc', 'Incorrect topic description' \r\n end",
"def create\n\t\turi = URI.parse(Counter::Application.config.simplyurl)\n\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\n\t\trequest = Net::HTTP::Post.new('/offsets.json')\n\t\tputs params\n\t\tputs params.slice(*['custids','acctids','itemids'])\n\t\t\n\t\t# ok, this join stuff is bogus - it encodes properly, but the other side only sees the last element and loses the array type - it's just string\n\t\t# this way, i 'split' it at the other side to recover my array\n\t\t# it should work without the join/split crap, but it doesn't\n\t\trequest.set_form_data({:custids => ( params['custids'] || []).join(','), :acctids => ( params['acctids'] || []).join(','), :itemids => ( params['itemids'] || []).join(','), :amount => params['amount'], :type => params['type']})\n\t\t\n\t\tputs request.body\n\t\t\n\t\tresponse = http.request(request)\n\t\tputs response.body\n\n respond_to do |format|\n format.html { render :text => response.code == :ok ? \"\" : response.body, status: response.code }\n format.json { render :text => response.code == :ok ? \"\" : response.body, status: response.code }\n end\n end",
"def post options\n rest_request({ method: :post }.merge(options))\n end"
] | [
"0.6262167",
"0.5959549",
"0.59119457",
"0.5901785",
"0.5881628",
"0.5876262",
"0.58638185",
"0.58558434",
"0.5832176",
"0.58291316",
"0.58195233",
"0.5811533",
"0.577161",
"0.5738022",
"0.5732125",
"0.57199883",
"0.5713084",
"0.5692667",
"0.5665253",
"0.5662356",
"0.5659618",
"0.5655965",
"0.56558615",
"0.56216806",
"0.55919",
"0.5590394",
"0.5570061",
"0.5567042",
"0.5553345",
"0.5552549",
"0.5533098",
"0.5530285",
"0.55301976",
"0.55262095",
"0.5515657",
"0.55093205",
"0.55032307",
"0.55002296",
"0.5499894",
"0.54947263",
"0.5491938",
"0.54900503",
"0.54886717",
"0.5487391",
"0.5472665",
"0.5465045",
"0.5456673",
"0.5442402",
"0.5441844",
"0.54359514",
"0.54359514",
"0.54359514",
"0.54353625",
"0.5422432",
"0.5417916",
"0.5416864",
"0.5412564",
"0.54021734",
"0.54001975",
"0.5399935",
"0.5398289",
"0.5395478",
"0.5395478",
"0.5390728",
"0.5382087",
"0.53800225",
"0.53787297",
"0.53778535",
"0.53778535",
"0.53778535",
"0.53778535",
"0.53778535",
"0.5367453",
"0.5366565",
"0.5363978",
"0.53633213",
"0.53633213",
"0.53633213",
"0.53633213",
"0.5359488",
"0.5356836",
"0.53480244",
"0.53469235",
"0.53436816",
"0.53416306",
"0.53376865",
"0.533526",
"0.5329229",
"0.5329229",
"0.5329229",
"0.5315636",
"0.53140026",
"0.5302623",
"0.53003246",
"0.5293737",
"0.52814835",
"0.5279431",
"0.5278912",
"0.5275575",
"0.5271149"
] | 0.571961 | 16 |
PATCH/PUT /foo91s/1 or /foo91s/1.json | def update
respond_to do |format|
if @foo91.update(foo91_params)
format.html { redirect_to @foo91, notice: "Foo91 was successfully updated." }
format.json { render :show, status: :ok, location: @foo91 }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @foo91.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_patch(path, data = {})\n api_request(:patch, path, :data => data)\n end",
"def patch!\n request! :patch\n end",
"def update(url, data)\n RestClient.put url, data, :content_type => :json\nend",
"def patch\n headers = {\"If-Match\" => @version}\n response = @context.request :patch, \"#{@path}/#{@id}\", @data.to_json, headers\n @version += 1\n response\n # 'X-HTTP-Method-Override' => 'PATCH'\n end",
"def patch(path, data)\n request 'PATCH', path, body: data.to_json\n end",
"def update_aos_version(args = {}) \n id = args['id']\n temp_path = \"/aosversions.json/{aosVersionId}\"\n path = temp_path\nargs.keys.each do |key|\n if (key == \"aosversionId\")\n args.delete(key)\n path = temp_path.gsub(\"{#{key}}\", id)\n end\nend\n puts \" PATH : #{path}\"\n put(path, args)\nend",
"def update(&block)\n validate_request()\n\n # Params includes all of the PATCH data at the top level along with other\n # other Rails-injected params like 'id', 'action', 'controller'. These\n # are harmless given no namespace collision and we're only interested in\n # the 'Operations' key for the actual patch data.\n #\n render(json: yield(self.safe_params()[:id], self.safe_params().to_hash()))\n end",
"def update!(params)\n res = @client.put(path, nil, params, \"Content-Type\" => \"application/json\")\n @attributes = res.json if res.status == 201\n res\n end",
"def patch(path, **args); end",
"def update # PATCH\n raise NotImplementedError\n end",
"def update\n respond_to do |format|\n if @foo93.update(foo93_params)\n format.html { redirect_to @foo93, notice: \"Foo93 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo93 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo93.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo83.update(foo83_params)\n format.html { redirect_to @foo83, notice: \"Foo83 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo83 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo83.errors, status: :unprocessable_entity }\n end\n end\n end",
"def put!\n request! :put\n end",
"def rest_edit(path, options={}, &blk)\n callback = Proc.new { |*args|\n @object = yield(*args) or pass\n rest_params.each { |k, v| @object.send :\"#{k}=\", v unless k == 'id' }\n\n return 400, @object.errors.to_json unless @object.valid?\n\n @object.save\n rest_respond @object\n }\n\n # Make it work with `Backbone.emulateHTTP` on.\n put path, &callback\n post path, &callback\n end",
"def rest_edit(path, options={}, &blk)\n callback = Proc.new { |*args|\n @object = yield(*args) or pass\n rest_params.each { |k, v| @object.send :\"#{k}=\", v unless k == 'id' }\n\n return 400, @object.errors.to_json unless @object.valid?\n\n @object.save\n rest_respond @object\n }\n\n # Make it work with `Backbone.emulateHTTP` on.\n put path, &callback\n post path, &callback\n end",
"def update\n respond_to do |format|\n if @foo98.update(foo98_params)\n format.html { redirect_to @foo98, notice: \"Foo98 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo98 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo98.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(type, info)\n path, info = type_info(type, :path), force_case(info)\n ida = type == :client ? 'client_id' : 'id'\n raise ArgumentError, \"info must include #{ida}\" unless id = info[ida]\n hdrs = headers\n if info && info['meta'] && (etag = info['meta']['version'])\n hdrs.merge!('if-match' => etag)\n end\n reply = json_parse_reply(@key_style,\n *json_patch(@target, \"#{path}/#{Addressable::URI.encode(id)}\", info, hdrs))\n\n # hide client endpoints that are not quite scim compatible\n type == :client && !reply ? get(type, info['client_id']): reply\n end",
"def update\n respond_to do |format|\n if @foo81.update(foo81_params)\n format.html { redirect_to @foo81, notice: \"Foo81 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo81 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo81.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo88.update(foo88_params)\n format.html { redirect_to @foo88, notice: \"Foo88 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo88 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo88.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @foo = Foo.find(params[:id])\n\n respond_to do |format|\n if @foo.update_attributes(params[:foo])\n format.html { redirect_to @foo, notice: 'Foo was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo34.update(foo34_params)\n format.html { redirect_to @foo34, notice: \"Foo34 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo34 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo34.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo56.update(foo56_params)\n format.html { redirect_to @foo56, notice: \"Foo56 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo56 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo56.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, data, params = {}, request_options = {})\n request(:patch, path, data, params)\n end",
"def update\n respond_to do |format|\n if @foo.update(foo_params)\n format.html { redirect_to @foo, notice: 'Foo was successfully updated.' }\n format.json { render :show, status: :ok, location: @foo }\n else\n format.html { render :edit }\n format.json { render json: @foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch options\n rest_request({ method: :patch }.merge(options))\n end",
"def patch options\n rest_request({ method: :patch }.merge(options))\n end",
"def update\n respond_to do |format|\n if @foo77.update(foo77_params)\n format.html { redirect_to @foo77, notice: \"Foo77 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo77 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo77.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo78.update(foo78_params)\n format.html { redirect_to @foo78, notice: \"Foo78 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo78 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo78.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rm_update path, data, msg\n\n re = rm_request path, data, 'PUT'\n puts re.body\n chk (re.code!='200'), msg + \"\\n#{re.code} #{re.msg}\\n\\n\"\n return true\n\nend",
"def update(resource,identifier,json)\n raise 'Not Yet Implemented'\n end",
"def patch(path, body_params = {})\n debug_log \"PATCH #{@host}#{path} body:#{body_params}\"\n headers = { 'Content-Type' => 'application/json' }\n res = connection.run_request :put, path, body_params.to_json, headers\n debug_log \"Response status:#{res.status}, body:#{res.body}\"\n res\n end",
"def update\n respond_to do |format|\n if @my_foo.update(my_foo_params)\n format.html { redirect_to @my_foo, notice: 'My foo was successfully updated.' }\n format.json { render :show, status: :ok, location: @my_foo }\n else\n format.html { render :edit }\n format.json { render json: @my_foo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo8.update(foo8_params)\n format.html { redirect_to @foo8, notice: \"Foo8 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo8 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo8.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo54.update(foo54_params)\n format.html { redirect_to @foo54, notice: \"Foo54 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo54 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo54.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @anything.update(anything_params)\n format.html { redirect_to @anything, notice: 'Anything was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @anything.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rest_patch(base_uri,json_payload,params)\n begin\n @response = RestClient.patch(base_uri,json_payload,params)\n rescue => e\n puts @response.code\n end\n return @response\n end",
"def update\n respond_to do |format|\n if @foo1.update(foo1_params)\n format.html { redirect_to @foo1, notice: \"Foo1 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo1 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo1.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_resource.update(api_v1_resource_params)\n format.html { redirect_to @api_v1_resource, notice: 'Resource was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_resource }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_resource.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo71.update(foo71_params)\n format.html { redirect_to @foo71, notice: \"Foo71 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo71 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo71.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @patch = Patch.find(params[:id])\n\n respond_to do |format|\n if @patch.update_attributes(params[:patch])\n format.html { redirect_to @patch, notice: 'Patch was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @patch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo10.update(foo10_params)\n format.html { redirect_to @foo10, notice: \"Foo10 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo10 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo10.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, params = {})\n request(:patch, path, params)\n end",
"def patch(path, params = {})\n request(:patch, path, params)\n end",
"def partial_update(klass, id, patchset, options = {}, format = nil)\n headers = {}\n headers[:accept] = \"#{format}\" if format\n format ||= @default_format\n options = { resource: klass, id: id, format: format}.merge options\n if [FHIR::Formats::ResourceFormat::RESOURCE_XML, FHIR::Formats::ResourceFormat::RESOURCE_XML_DSTU2].include?(format)\n options[:format] = FHIR::Formats::PatchFormat::PATCH_XML\n headers[:content_type] = \"#{FHIR::Formats::PatchFormat::PATCH_XML}\"\n elsif [FHIR::Formats::ResourceFormat::RESOURCE_JSON, FHIR::Formats::ResourceFormat::RESOURCE_JSON_DSTU2].include?(format)\n options[:format] = FHIR::Formats::PatchFormat::PATCH_JSON\n headers[:content_type] = \"#{FHIR::Formats::PatchFormat::PATCH_JSON}\"\n end\n headers[:prefer] = @return_preference if @use_return_preference\n reply = patch resource_url(options), patchset, fhir_headers(headers)\n reply.resource = parse_reply(klass, format, reply)\n reply.resource_class = klass\n reply\n end",
"def update\n respond_to do |format|\n if @foo51.update(foo51_params)\n format.html { redirect_to @foo51, notice: \"Foo51 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo51 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo51.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @patch.update(patch_params)\n format.html { redirect_to @patch, notice: 'Patch was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @patch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo11.update(foo11_params)\n format.html { redirect_to @foo11, notice: \"Foo11 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo11 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo11.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(operation, path, value = nil)\n ensure_client && ensure_uri\n body = {\n 'op' => operation,\n 'path' => path,\n 'value' => value\n }\n response = @client.rest_patch(@data['uri'], { 'Content-Type' => 'application/json-patch+json', 'body' => [body] }, @api_version)\n @client.response_handler(response)\n end",
"def update\n respond_to do |format|\n if @foo73.update(foo73_params)\n format.html { redirect_to @foo73, notice: \"Foo73 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo73 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo73.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo97.update(foo97_params)\n format.html { redirect_to @foo97, notice: \"Foo97 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo97 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo97.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tenant_circle(args = {}) \n put(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def http_put(path, data, content_type = 'application/json')\n http_methods(path, :put, data, content_type)\n end",
"def update\n respond_to do |format|\n format.xml { head :method_not_allowed }\n format.json { head :method_not_allowed }\n end\n end",
"def update\n respond_to do |format|\n if @foo40.update(foo40_params)\n format.html { redirect_to @foo40, notice: \"Foo40 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo40 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo40.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @rest_api.update(rest_api_params)\n format.html { redirect_to @rest_api, notice: 'Rest api was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @rest_api.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo32.update(foo32_params)\n format.html { redirect_to @foo32, notice: \"Foo32 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo32 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo32.errors, status: :unprocessable_entity }\n end\n end\n end",
"def from_merge_patch_json\n if request.patch?\n from_json\n else\n 415\n end\n end",
"def update\n @foobar = Foobar.find(params[:id])\n\n respond_to do |format|\n if @foobar.update_attributes(params[:foobar])\n format.html { redirect_to @foobar, notice: 'Foobar was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foobar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n render json: Company.update(params[\"id\"], params[\"company\"])\n end",
"def update\n respond_to do |format|\n if @foo13.update(foo13_params)\n format.html { redirect_to @foo13, notice: \"Foo13 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo13 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo13.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n# respond_to do |format|\n# if @req.update(req_params)\n format.json { render :json => {:status => 'success'}}\n# format.html { redirect_to @req, notice: 'Req was successfully updated.' }\n# format.json { render :show, status: :ok, location: @req }\n# else\n format.json { render :json => {:status => 'failed'}}\n# format.html { render :edit }\n# format.json { render json: @req.errors, status: :unprocessable_entity }\n# end\n# end\n end",
"def update options={}\n client.put(\"/#{id}\", options)\n end",
"def update\n respond_to do |format|\n if @foo37.update(foo37_params)\n format.html { redirect_to @foo37, notice: \"Foo37 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo37 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo37.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_radios_for_array(args = {}) \n id = args['id']\n temp_path = \"/radios.json/{arrayId}\"\n path = temp_path\nargs.keys.each do |key|\n if (key == \"radioId\")\n args.delete(key)\n path = temp_path.gsub(\"{#{key}}\", id)\n end\nend\n puts \" PATH : #{path}\"\n put(path, args)\nend",
"def patch(path, opts = {})\n request(:patch, path, opts).body\n end",
"def update\n respond_to do |format|\n if @foo38.update(foo38_params)\n format.html { redirect_to @foo38, notice: \"Foo38 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo38 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo38.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo58.update(foo58_params)\n format.html { redirect_to @foo58, notice: \"Foo58 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo58 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo58.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo63.update(foo63_params)\n format.html { redirect_to @foo63, notice: \"Foo63 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo63 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo63.errors, status: :unprocessable_entity }\n end\n end\n end",
"def http_method_modifies_resource?\n ['PUT','POST','PATCH'].include?(method.to_s.upcase)\n end",
"def patch(path, params)\n time(\"PATCH #{path}\") { Cloudflarer.new.patch(path, params) }\n end",
"def update\n respond_to do |format|\n if @foo20.update(foo20_params)\n format.html { redirect_to @foo20, notice: \"Foo20 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo20 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo20.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(url, payload, headers={})\n RestClient.patch url, payload, headers\n end",
"def update(data = :object || :json)\n end",
"def update\n respond_to do |format|\n if @api_v1_todo.update(api_v1_todo_params)\n format.json { render json: @api_v1_todo, status: :ok }\n else\n format.json { render json: @api_v1_todo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(uri, options = T.unsafe(nil)); end",
"def put(path, body = nil, ctype = 'application/json')\n make_call(mk_conn(path, 'Content-Type': ctype,\n 'Accept': 'application/json'),\n :put, nil, body.to_json)\n end",
"def update(id: nil, body: nil)\n perform(:put, \"#{@resource_type}/#{id}\", body)\n end",
"def update_by_body\n @person = Person.find(person_update_params[:id])\n\n if @person.update_attributes(person_update_params)\n render json: { status: 'PUT Success' }, status: :ok\n else\n render json: { status: 'Error', message:'Error updating person', person: @person.errors }, status: :unprocessable_entity\n end\n end",
"def update\n @foo_model = FooModel.find(params[:id])\n\n respond_to do |format|\n if @foo_model.update_attributes(params[:foo_model])\n format.html { redirect_to @foo_model, notice: 'Foo model was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foo_model.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(action, **args); end",
"def update\n if request.content_type == \"application/json\"\n # .update is like a \"update people set ...\" in sql\n if @person.update(person_params)\n render json: @person\n else\n render json: @person.errors, status: :not_found\n end\n else\n render status: :bad_request\n end\n end",
"def put(*args)\n request :put, *args\n end",
"def patch(operation, path, value)\n response = @client.rest_patch(@data['uri'], 'body' => [{ op: operation, path: path, value: value }])\n @client.response_handler(response)\n end",
"def update\n respond_to do |format|\n if @foo19.update(foo19_params)\n format.html { redirect_to @foo19, notice: \"Foo19 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo19 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo19.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n status_unsupported_media_type && return unless content_type_header?\n\n # Parse in the FHIR::Patient\n contents = FHIR.from_contents(request.body.string)\n status_bad_request && return if contents.nil? || !contents.valid?\n\n resource_type = params.permit(:resource_type)[:resource_type]&.downcase\n case resource_type\n when 'patient'\n updates = Patient.from_fhir(contents).select { |_k, v| v.present? }\n resource = get_patient(params.permit(:id)[:id])\n else\n status_bad_request && return\n end\n\n status_forbidden && return if resource.nil?\n\n # Try to update the resource\n status_bad_request && return if updates.nil? || !resource.update(updates)\n\n status_ok(resource.as_fhir) && return\n rescue StandardError\n render json: operation_outcome_fatal.to_json, status: :internal_server_error\n end",
"def update\n @stuff = Stuff.find(params[:id])\n\n respond_to do |format|\n if @stuff.update_attributes(params[:stuff])\n format.html { redirect_to @stuff, :notice => 'Stuff was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @stuff.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def patch(payload)\n post_like payload, Net::HTTP::Patch.new(@uri.path)\n end",
"def patch(operation, path, value = nil)\n ensure_client && ensure_uri\n body = [{ 'op' => operation, 'path' => path, 'value' => value }]\n patch_options = { 'If-Match' => @data['eTag'] }\n response = @client.rest_patch(@data['uri'], patch_options.merge('body' => body), @api_version)\n @client.response_handler(response)\n end",
"def update_request?(http_method = nil)\n http_method = http_method.downcase.to_sym if http_method.is_a?(String)\n %i[put post patch].include?(http_method || @verb)\n end",
"def update\n respond_to do |format|\n if @major.update(major_params)\n format.html { redirect_to @major, notice: 'Major was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @major.errors, status: :unprocessable_entity }\n end\n end\n end",
"def fire_patch(url_or_path, entity, options = {}, &block)\n url = absolute_url(url_or_path)\n headers = {:Accept => MEDIA_TYPE_JSON, :'Content-type' => ENCODED_MEDIA_TYPE_JSON_PATCH}.\n merge(options.fetch(:headers, {}))\n headers = merge_log_weasel_header(headers)\n timeout = options.fetch(:timeout, Ladon.default_request_timeout)\n body = encode_entity(entity)\n response = Typhoeus::Request.run(url, headers: headers, timeout: timeout, body: body, method: :patch)\n handle_response(response, method: :patch, url: url, default_data: options[:default_data],\n raise_on_error: options[:raise_on_error], &block)\n end",
"def update\n respond_to do |format|\n if @foo62.update(foo62_params)\n format.html { redirect_to @foo62, notice: \"Foo62 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo62 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo62.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_job_success(job_id, success)\n RestClient.put \"#{rest_jobs_url}/#{job_id}\", {\"passed\" => success}.to_json, :content_type => :json\nend",
"def update\n # respond_to do |format|\n # if @thing.update(thing_params)\n # format.html { redirect_to @thing, notice: 'Thing was successfully updated.' }\n # format.json { render :show, status: :ok, location: @thing }\n # else\n # format.html { render :edit }\n # format.json { render json: @thing.errors, status: :unprocessable_entity }\n # end\n # end\n end",
"def edit_resource(type, id, data)\n bad_attrs = data_includes_invalid_attrs(data)\n\n if bad_attrs.present?\n msg = \"Attribute(s) '#{bad_attrs}' should not be specified for updating a server resource\"\n raise BadRequestError, msg\n end\n\n super\n end",
"def update\n fn = params[:id].gsub('DOTDOT','.').gsub('SLASHSLASH','/')\n File.open(fn,'w+') { |f| \n f.puts params[:content]\n }\n respond_to do |format|\n format.json { render json: { success: true} }\n end\n end",
"def update\n @thing = Thing.find(params[:id])\n\n respond_to do |format|\n if @thing.update_attributes(params[:thing])\n format.html { redirect_to things_path, notice: 'Your thing was successfully updated!' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @thing.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foo52.update(foo52_params)\n format.html { redirect_to @foo52, notice: \"Foo52 was successfully updated.\" }\n format.json { render :show, status: :ok, location: @foo52 }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @foo52.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foobar.update(foobar_params)\n format.html { redirect_to @foobar, notice: 'Foobar was successfully updated.' }\n format.json { render :show, status: :ok, location: @foobar }\n else\n format.html { render :edit }\n format.json { render json: @foobar.errors, status: :unprocessable_entity }\n end\n end\n end",
"def put(id, json)\n with_endpoint do |endpoint|\n url = [endpoint, @resource_name, id].compact.join('/')\n url += \"/\" \n return HTTParty.put(url, :body => json, :timeout => 4, :headers => { 'Content-Type' => 'application/json' })\n end\n end"
] | [
"0.65227926",
"0.63594806",
"0.6279403",
"0.6272962",
"0.62227356",
"0.6129994",
"0.611725",
"0.60883826",
"0.6076311",
"0.6040519",
"0.6021801",
"0.6013734",
"0.6010367",
"0.601013",
"0.601013",
"0.60049385",
"0.5999497",
"0.5998313",
"0.5996826",
"0.5977811",
"0.59506947",
"0.59445554",
"0.5917922",
"0.5908782",
"0.59084255",
"0.59084255",
"0.59065187",
"0.5905",
"0.5900783",
"0.5894925",
"0.5884241",
"0.58825564",
"0.5875632",
"0.5865121",
"0.58641726",
"0.5857793",
"0.58572114",
"0.5844843",
"0.58418757",
"0.5837183",
"0.58303183",
"0.5818684",
"0.5818684",
"0.57983476",
"0.57948875",
"0.5793063",
"0.5785071",
"0.57776594",
"0.5764841",
"0.5759884",
"0.5747961",
"0.57418275",
"0.5716017",
"0.5713414",
"0.56982607",
"0.5694463",
"0.56747496",
"0.5671702",
"0.5665998",
"0.5653414",
"0.56437",
"0.5642826",
"0.56392264",
"0.56391555",
"0.5636557",
"0.5634935",
"0.5633272",
"0.56309265",
"0.56270534",
"0.562506",
"0.56163466",
"0.56147355",
"0.5614607",
"0.5614464",
"0.56122917",
"0.56089413",
"0.560615",
"0.5595479",
"0.5581508",
"0.55689114",
"0.5565435",
"0.5554984",
"0.55502105",
"0.5547534",
"0.5545239",
"0.553237",
"0.55313367",
"0.55219907",
"0.5520335",
"0.5511827",
"0.5500551",
"0.54912555",
"0.5490219",
"0.548952",
"0.54881597",
"0.54813254",
"0.54741985",
"0.5472941",
"0.54704595",
"0.5468764"
] | 0.6273329 | 3 |
DELETE /foo91s/1 or /foo91s/1.json | def destroy
@foo91.destroy
respond_to do |format|
format.html { redirect_to foo91s_url, notice: "Foo91 was successfully destroyed." }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def delete(*rest) end",
"def cmd_delete argv\n setup argv\n uuid = @hash['uuid']\n response = @api.delete(uuid)\n msg response\n return response\n end",
"def http_delete(path, data = nil, content_type = 'application/json')\n http_methods(path, :delete, data, content_type)\n end",
"def api_delete(path, data = {})\n api_request(:delete, path, :data => data)\n end",
"def delete path\n make_request(path, \"delete\", {})\n end",
"def delete(name); end",
"def delete(name); end",
"def test_delete_preconditions_failed\n request = Http::Request.new(\n 'DELETE',\n '/file1',\n 'If-Match' => \"\\\"#{Digest::MD5.hexdigest('bar')}\\\"\"\n )\n\n response = self.request(request)\n\n assert_equal(\n 412,\n response.status,\n \"Incorrect status code. Response body: #{response.body_as_string}\"\n )\n end",
"def delete(path)\n RestClient.delete request_base+path\n end",
"def delete_json(path)\n url = [base_url, path].join\n resp = HTTParty.delete(url, headers: standard_headers)\n parse_json(url, resp)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def destroy\n @foo54.destroy\n respond_to do |format|\n format.html { redirect_to foo54s_url, notice: \"Foo54 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo71.destroy\n respond_to do |format|\n format.html { redirect_to foo71s_url, notice: \"Foo71 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def deletef\n url = prefix + \"deletef\" + id_param\n return response(url)\n end",
"def destroy\n @foo56.destroy\n respond_to do |format|\n format.html { redirect_to foo56s_url, notice: \"Foo56 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo93.destroy\n respond_to do |format|\n format.html { redirect_to foo93s_url, notice: \"Foo93 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo83.destroy\n respond_to do |format|\n format.html { redirect_to foo83s_url, notice: \"Foo83 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo97.destroy\n respond_to do |format|\n format.html { redirect_to foo97s_url, notice: \"Foo97 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete!( opts = {} )\n http_action :delete, nil, opts\n end",
"def delete!(*rest) end",
"def delete(name)\n\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def delete\n url = prefix + \"delete\" + id_param\n return response(url)\n end",
"def delete(resource_type,identifier)\n path = '/api/' + resource_type.to_s + '/' + slugify(identifier)\n http_delete(path)\n end",
"def delete(path)\n repository = path.split(/\\//)[2]\n objectid = path.split(/\\//)[3]\n if storage_fetch(repository, objectid) && storage_delete(repository, objectid)\n ['200', {}, []]\n else\n ['404', {}, [\"Repository #{repository} or ObjectID #{objectid} not found: #{path}\"]]\n end\n end",
"def destroy\n @foo51.destroy\n respond_to do |format|\n format.html { redirect_to foo51s_url, notice: \"Foo51 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo = Foo.find(params[:id])\n @foo.destroy\n\n respond_to do |format|\n format.html { redirect_to foos_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @foo81.destroy\n respond_to do |format|\n format.html { redirect_to foo81s_url, notice: \"Foo81 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo34.destroy\n respond_to do |format|\n format.html { redirect_to foo34s_url, notice: \"Foo34 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(url, headers = {})\n http :delete, \"#{url}.json\", headers\n end",
"def destroy\n @foo73.destroy\n respond_to do |format|\n format.html { redirect_to foo73s_url, notice: \"Foo73 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo63.destroy\n respond_to do |format|\n format.html { redirect_to foo63s_url, notice: \"Foo63 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo78.destroy\n respond_to do |format|\n format.html { redirect_to foo78s_url, notice: \"Foo78 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo98.destroy\n respond_to do |format|\n format.html { redirect_to foo98s_url, notice: \"Foo98 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def test_delete_not_found\n request = Http::Request.new('DELETE', '/file2')\n response = self.request(request)\n\n assert_equal(\n 404,\n response.status,\n \"Incorrect status code. Response body: #{response.body_as_string}\"\n )\n end",
"def destroy\n @foo77.destroy\n respond_to do |format|\n format.html { redirect_to foo77s_url, notice: \"Foo77 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(splat)\n bad_request if splat.empty?\n _delete resolve_uri(splat[0])\n end",
"def delete\n res = HTTParty.get URL, headers: HEADERS\n message = JSON.parse res.body, symbolize_names: true\n if res.code == 200\n numSubs = message[:data].count\n if numSubs > 0\n message[:data].each do |sub|\n id = sub[:id]\n delRes = HTTParty.delete \"#{URL}/#{id}\", headers: HEADERS\n #TODO handle status codes\n end\n end\n end\n end",
"def do_delete(uri = \"\")\n @connection.delete do |req|\n req.url uri\n req.headers['Content-Type'] = 'application/json'\n end\n end",
"def delete(path)\n request(:delete, path)\n end",
"def delete(type, id)\n http_delete @target, \"#{type_info(type, :path)}/#{Addressable::URI.encode(id)}\", @auth_header, @zone\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete(options={})\n connection.delete(\"/\", @name)\n end",
"def delete(path, params = {})\n Chirpy.request params.merge({:path => path, :method => 'delete'}.merge(authentication))\n end",
"def delete(*args)\n request(:delete, *args)\n end",
"def destroy\n @foo88.destroy\n respond_to do |format|\n format.html { redirect_to foo88s_url, notice: \"Foo88 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete!\n request! :delete\n end",
"def destroy\n @foo52.destroy\n respond_to do |format|\n format.html { redirect_to foo52s_url, notice: \"Foo52 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path, params)\n headers = {:Authorization => \"token #{token}\", :content_type => :json, :accept => :json}\n res = RestClient.delete(\"#{github_api_uri}/#{path}\", params.to_json, headers)\n Yajl.load(res)\n end",
"def delete(resource)\n headers = base_headers.merge('Content-Type' => 'application/json')\n url = \"#{@base_url}/#{resource}\"\n\n @logger.debug(\"DELETE request Url: #{url}\")\n @logger.debug(\"-- Headers: #{headers}\")\n\n x = HTTParty.delete(url, headers: headers)\n puts x.inspect\n x\n end",
"def destroy\n @foo1.destroy\n respond_to do |format|\n format.html { redirect_to foo1s_url, notice: \"Foo1 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo62.destroy\n respond_to do |format|\n format.html { redirect_to foo62s_url, notice: \"Foo62 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo40.destroy\n respond_to do |format|\n format.html { redirect_to foo40s_url, notice: \"Foo40 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo64.destroy\n respond_to do |format|\n format.html { redirect_to foo64s_url, notice: \"Foo64 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(major,minor)\n major = major.to_sym\n if minor\n delete_hash = minor\n else\n if storage.hash_exists?(major)\n delete_hash = storage.find(major)\n else\n puts 'Delete hash not found in storage.'\n puts 'Use: imgurr delete <id> <delete_hash>'\n return\n end\n end\n if ImgurAPI.delete(delete_hash)\n puts 'Successfully deleted image from Imgur'\n storage.delete(major)\n storage.save\n else\n puts 'Unauthorized Access. Wrong delete hash?'\n end\n end",
"def delete(path)\n request 'DELETE', path\n end",
"def destroy\n @foo37.destroy\n respond_to do |format|\n format.html { redirect_to foo37s_url, notice: \"Foo37 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(*uris); end",
"def destroy\n @foo13.destroy\n respond_to do |format|\n format.html { redirect_to foo13s_url, notice: \"Foo13 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete\n client.delete(url)\n @deleted = true\nend",
"def destroy\n @foo58.destroy\n respond_to do |format|\n format.html { redirect_to foo58s_url, notice: \"Foo58 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def delete(path)\n\t\trequest(path, :delete)\n\tend",
"def destroy\n @foo38.destroy\n respond_to do |format|\n format.html { redirect_to foo38s_url, notice: \"Foo38 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path_part, additional_headers = {}, &block)\n api_request { @rest.delete('/REST/' + path_part, \"\", additional_headers, &block) }\n end",
"def delete(path, data={})\n request(:delete, path, data)\n end",
"def delete(name)\n request(uri = uri(name), Net::HTTP::Delete.new(uri.request_uri))\n end",
"def destroy\n @foo8.destroy\n respond_to do |format|\n format.html { redirect_to foo8s_url, notice: \"Foo8 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @anything.destroy\n respond_to do |format|\n format.html { redirect_to anythings_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foo32.destroy\n respond_to do |format|\n format.html { redirect_to foo32s_url, notice: \"Foo32 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path, *data, &block)\n map(path, R3::DELETE, *data, &block)\n end",
"def delete(*args)\n prepare_request(:delete, args)\n @@client.add(:delete, @path, *args)\n end",
"def delete(url, resource_name, options = {})\n build_response(resource_name) do\n connection.delete do |req|\n req.url url\n req.body = options.to_json\n end\n end\n end",
"def test_del\n header 'Content-Type', 'application/json'\n\n data = File.read 'sample-traces/0.json'\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n\n id = last_response.body\n\n delete \"/traces/#{id}\"\n assert last_response.ok?\n\n get \"/traces/#{id}\"\n\n contents = JSON.parse last_response.body\n assert_kind_of(Hash, contents, 'Response contents is not a hash')\n assert contents.key? 'description'\n assert(!last_response.ok?)\n end",
"def rm_update path, data, msg\n\n re = rm_request path, data, 'PUT'\n puts re.body\n chk (re.code!='200'), msg + \"\\n#{re.code} #{re.msg}\\n\\n\"\n return true\n\nend",
"def destroy\n @ruby.destroy\n respond_to do |format|\n format.html { redirect_to rubies_url }\n format.json { head :no_content }\n end\n end",
"def delete(path, params)\n parse_response @client[path].delete(:params => params)\n end",
"def destroy\n @foo10.destroy\n respond_to do |format|\n format.html { redirect_to foo10s_url, notice: \"Foo10 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(path, data = {})\n self.class.delete path, :body => data.merge(:u => access_token)\n end",
"def delete_file(filename,repo)\n curl_delete(\"#{self.host}/api2/repos/#{repo}/file/?p=#{filename}\").body_str\n end",
"def api_delete(action, data)\n api_request(action, data, 'DELETE')\n end",
"def delete(container_name, file_name)\n validate_path_elements(container_name, file_name)\n\n client.request(\n method: :delete,\n path: \"#{container_name}/#{file_name}\",\n expected: 204\n )\n end",
"def delete(path, options = {}, signature = false, raw = false, unformatted = false, no_response_wrapper = self.no_response_wrapper, signed = sign_requests)\n request(:delete, path, options, signature, raw, unformatted, no_response_wrapper, signed)\n end",
"def delete(key)\n log \"deleting #{key} from #{container_path}\"\n object_path = File.join(container_path, Raca::Util.url_encode(key))\n response = storage_client.delete(object_path)\n (200..299).cover?(response.code.to_i)\n end",
"def delete\n execute_request('DELETE') do |uri, headers|\n HTTP.http_client.delete(uri, header: headers)\n end\n end",
"def delete(path, **options)\n execute :delete, path, options\n end",
"def delete(path, options={})\n url = build_url path, options\n headers = options[:headers] || {}\n # nothing returned in response body for DELETE\n Response.new(@client[url].delete headers)\n rescue RestClient::Exception => e\n Response.new e.response\n end",
"def _delete(type, *args)\n type = type.to_s.camelize\n metadata = args.map { |full_name| {:full_name => full_name} }\n request :delete do |soap|\n soap.body = {\n :metadata => metadata\n }.merge(attributes!(type))\n end\n end",
"def cfa_delete\n Rails.logger.info_log.info \" I,[#{Time.now.strftime(\"%Y-%m-%d %H:%M:%S %Z\")}]\" \"INFO -- : Entered in cfa titles cfa_delete method\"\n begin\n id=params[\"format\"] \n cfa=RestClient.delete $api_service+'/cfa_titles/'+id\n rescue =>e\n Rails.logger.custom_log.error { \"#{e} Cfa controller delete method\" }\n end\n redirect_to action: \"index\"\n end",
"def delete(name)\n raise('wrong type: String required') unless name.is_a?(String)\n raise('wrong value: name must be valid') unless !name.nil? && !name.empty?\n\n @client.post({\n 'action' => 'del',\n 'object' => 'htpl',\n 'values' => name,\n }.to_json)\n end",
"def delete(command)\n pp @client.files.delete(clean_up(command[1]))\n end",
"def destroy\n @baz41.destroy\n respond_to do |format|\n format.html { redirect_to baz41s_url, notice: \"Baz41 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(uuid, key)\n request(method: 'DELETE', uri: \"/files/#{uuid}/metadata/#{key}/\")\n end",
"def delete(path, params = {})\n debug_log \"DELETE #{@host}#{path} params:#{params}\"\n res = connection.delete path, params\n debug_log \"Response status:#{res.status}, body:#{res.body}\"\n res\n end",
"def destroy\n @foo11.destroy\n respond_to do |format|\n format.html { redirect_to foo11s_url, notice: \"Foo11 was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def delete(action, **args); end",
"def delete\n request(:delete)\n end"
] | [
"0.694556",
"0.6626908",
"0.65868354",
"0.646368",
"0.6453266",
"0.64302903",
"0.6411858",
"0.6411858",
"0.6354994",
"0.6354599",
"0.6352906",
"0.6343519",
"0.6343519",
"0.6327255",
"0.6301713",
"0.62971777",
"0.62939644",
"0.62869596",
"0.6286874",
"0.62839246",
"0.62792635",
"0.627562",
"0.6275125",
"0.62669003",
"0.62631977",
"0.6243788",
"0.6240982",
"0.62392646",
"0.6238031",
"0.6236645",
"0.6233724",
"0.62188673",
"0.621839",
"0.62032825",
"0.6201707",
"0.61783886",
"0.61737925",
"0.6163213",
"0.61631066",
"0.61608183",
"0.6159776",
"0.61462945",
"0.61416465",
"0.61395687",
"0.61395687",
"0.6138777",
"0.6132346",
"0.6131229",
"0.6123531",
"0.61195433",
"0.61156464",
"0.6113102",
"0.6106649",
"0.60996556",
"0.6098824",
"0.60942245",
"0.6091795",
"0.60818374",
"0.60801333",
"0.60767496",
"0.6071503",
"0.60663766",
"0.6064607",
"0.6057931",
"0.6054749",
"0.60497916",
"0.60446024",
"0.60370266",
"0.60357517",
"0.6032725",
"0.60321873",
"0.6031676",
"0.6030649",
"0.6029442",
"0.60269284",
"0.6022077",
"0.60210454",
"0.6018228",
"0.601591",
"0.6015614",
"0.60146886",
"0.6012502",
"0.6011418",
"0.60065097",
"0.5998692",
"0.59954345",
"0.5995135",
"0.59922224",
"0.59900707",
"0.59895545",
"0.5985544",
"0.59848243",
"0.59800094",
"0.59796894",
"0.5979366",
"0.59782946",
"0.59769744",
"0.5973056",
"0.5972213",
"0.59713835"
] | 0.64242345 | 6 |
Use callbacks to share common setup or constraints between actions. | def set_foo91
@foo91 = Foo91.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup_handler\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def workflow\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def setup\n # override and do something appropriate\n end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def before_action \n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def setup_signals; end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def after_set_callback; end",
"def initialize(*args)\n super\n @action = :set\nend",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def around_hooks; end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def call\n setup_context\n super\n end",
"def duas1(action)\n action.call\n action.call\nend",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] | [
"0.6163754",
"0.6045816",
"0.5944853",
"0.59169096",
"0.58892167",
"0.58342934",
"0.5776148",
"0.57057375",
"0.57057375",
"0.56534296",
"0.56209534",
"0.54244673",
"0.54101455",
"0.54101455",
"0.54101455",
"0.53951085",
"0.5378493",
"0.53563684",
"0.53399915",
"0.5338049",
"0.53307265",
"0.5312121",
"0.5298173",
"0.5296388",
"0.52952695",
"0.5258086",
"0.52430934",
"0.5237911",
"0.5237911",
"0.5237911",
"0.5237911",
"0.5237911",
"0.52335346",
"0.5232943",
"0.5226392",
"0.52221715",
"0.5217978",
"0.52136153",
"0.52076435",
"0.52067244",
"0.5175402",
"0.5174649",
"0.5173085",
"0.5165201",
"0.5162052",
"0.5157932",
"0.5152905",
"0.5152353",
"0.5150909",
"0.514719",
"0.5138596",
"0.51333916",
"0.51139015",
"0.5113431",
"0.5113431",
"0.5109581",
"0.51066816",
"0.5091428",
"0.5089407",
"0.5082971",
"0.50822043",
"0.50668514",
"0.5055155",
"0.50525695",
"0.50499475",
"0.50499475",
"0.5034445",
"0.50249445",
"0.5022226",
"0.50167644",
"0.5014211",
"0.4999924",
"0.49996212",
"0.49978727",
"0.4989682",
"0.4989682",
"0.49851838",
"0.49817684",
"0.4979687",
"0.49787104",
"0.49688423",
"0.49664098",
"0.49564412",
"0.49561828",
"0.49547398",
"0.4953481",
"0.4952925",
"0.4946049",
"0.494379",
"0.49319315",
"0.49313048",
"0.49269778",
"0.49263066",
"0.49257493",
"0.4924526",
"0.49212465",
"0.49173486",
"0.4915802",
"0.49151486",
"0.49150333",
"0.49147308"
] | 0.0 | -1 |
Only allow a list of trusted parameters through. | def foo91_params
params.require(:foo91).permit(:foo1, :foo2, :foo3, :foo4, :foo5)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def allow_params_authentication!; end",
"def whitelisted_args\n args.select &:allowed\n end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def filtered_parameters; end",
"def sanitize_params_for user, params, allowed_params\n params.each do |key, val|\n #if allowed_params.include?(key)\n #sanitize!(user, params, key) if key =~ /_attributes|_ids$/\n #else\n #params.delete(key)\n #end\n params.delete(key) unless allowed_params.include?(key.to_sym)\n end\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def expected_permitted_parameter_names; end",
"def sanitize_parameters!(sanitizer, params)\n # replace :readwrite with :onlyif\n if params.has_key?(:readwrite)\n warn \":readwrite is deprecated. Replacing with :onlyif\"\n params[:onlyif] = params.delete(:readwrite)\n end\n\n # add default parameters\n bindata_default_parameters.each do |k,v|\n params[k] = v unless params.has_key?(k)\n end\n\n # ensure mandatory parameters exist\n bindata_mandatory_parameters.each do |prm|\n if not params.has_key?(prm)\n raise ArgumentError, \"parameter ':#{prm}' must be specified \" +\n \"in #{self}\"\n end\n end\n\n # ensure mutual exclusion\n bindata_mutually_exclusive_parameters.each do |param1, param2|\n if params.has_key?(param1) and params.has_key?(param2)\n raise ArgumentError, \"params #{param1} and #{param2} \" +\n \"are mutually exclusive\"\n end\n end\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def check_params; true; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def allowed?(*_)\n true\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def allowed_params(parameters)\n parameters.select do |name, values|\n values.location != \"path\"\n end\n end",
"def secure_params\n return @secure_params if @secure_params\n\n defn = implementation_class.definition\n field_list = [:master_id] + defn.field_list_array\n\n res = params.require(controller_name.singularize.to_sym).permit(field_list)\n res[implementation_class.external_id_attribute.to_sym] = nil if implementation_class.allow_to_generate_ids?\n @secure_params = res\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permit( params, whitelist, name = nil )\n raise 'Parametrization not yet configured' unless @configured\n whitelist ||= []\n px = params.respond_to?( :permit ) ? params : ActionController::Parameters.new( params )\n px = dig(px, name)\n px.permit( *whitelist )\n end",
"def valid_params?; end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def url_allowlist=(_arg0); end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def list_params\n params.permit(:list_name)\n end",
"def valid_params_request?; end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def param_list(param_type, name, type, required, description = nil, allowed_values = [], hash = {})\n hash.merge!({allowable_values: {value_type: \"LIST\", values: allowed_values}})\n param(param_type, name, type, required, description, hash)\n end",
"def safelists; end",
"def authorize_own_lists\n authorize_lists current_user.lists\n end",
"def listed_params\n params.permit(:listed, :list_id, :listable_id, :listable_type, :campsite_id)\n end",
"def lists_params\n params.require(:list).permit(:name)\n\n end",
"def list_params\n params.require(:list).permit(:name, :user_id)\n end",
"def list_params\n params.require(:list).permit(:name, :description, :type, :privacy, :allow_edit, :rating, :votes_count, :user_id)\n end",
"def check_params\n true\n end",
"def authorize_own_or_shared_lists\n authorize_lists current_user.all_lists\n end",
"def user_pref_list_params\n\t\tparams.require(:user).permit(:preference_list)\n\tend",
"def may_contain!(*keys)\n self.allow_only_permitted = true\n self.permitted_keys = [*permitted_keys, *keys].uniq\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def whitelist; end",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.permit(:name)\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :list, :references)\n end",
"def cancan_parameter_sanitizer\n resource = controller_name.singularize.to_sym\n method = \"#{resource}_params\"\n params[resource] &&= send(method) if respond_to?(method, true)\n end",
"def list_params\n params.require(:list).permit(:name).merge(user_id: current_user.id)\n end",
"def whitelist_place_params\n params.require(:place).permit(:place_name, :unlock, :auth, :is_deep_checked, :parent_ADM4, :parent_ADM3, :parent_ADM2, :parent_ADM1, :parent_country, feature_code: [], same_as: [], related_authority: [], altlabel: [], note: []) # Note - arrays need to go at the end or an error occurs!\n end",
"def list_params\n params.fetch(:list, {}).permit(:user_id, :name, :active)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def secure_params(require_param, permit_keys)\n params.require(require_param).permit(*permit_keys)\n end",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def permitted_params\n []\n end",
"def price_list_params\n params.fetch(:price_list, {}).permit(:name, :valid_from, :valid_to, :active,\n :all_warehouses, :all_users, :all_contact_groups,\n warehouse_ids: [], price_lists_user_ids: [], contact_group_ids: [])\n end",
"def params(list)\n @declared_params = list\n end",
"def admin_review_params\n params.fetch(:review, {}).permit(whitelisted_params)\n end",
"def saved_list_params\n params.require(:saved_list).permit(:user_id)\n end",
"def allow(ids); end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def filter_params(param_set, **kwargs)\r\n begin\r\n key = kwargs[:key]\r\n params.require(key).permit(*param_set)\r\n rescue Exception\r\n params.permit(*param_set)\r\n end\r\n end",
"def valid_parameters\n sort_symbols(@interface.allowed_parameters)\n end",
"def validate_paramified_params\n self.class.paramify_methods.each do |method|\n params = send(method)\n transfer_errors_from(params, TermMapper.scope(params.group)) if !params.valid?\n end\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def secure_params\n return @secure_params if @secure_params\n\n @implementation_class = implementation_class\n resname = @implementation_class.name.ns_underscore.gsub('__', '_').singularize.to_sym\n @secure_params = params.require(resname).permit(*permitted_params)\n end",
"def refine_permitted_params(param_list)\n res = param_list.dup\n\n ms_keys = res.select { |a| columns_hash[a.to_s]&.array }\n ms_keys.each do |k|\n res.delete(k)\n res << { k => [] }\n end\n\n res\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :description, recipient_id_array: [])\n end",
"def safelist; end",
"def sponsor_params\n params.require(:sponsor).permit(WHITE_LIST)\n end",
"def valid_for_params_auth?; end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def shopping_list_params\n params.require(:shopping_list).permit!\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def permitters\n @_parametrizr_permitters || {}\n end",
"def allow_params(action, keys: nil, except: nil, &blk)\n keys &&= Array.wrap(keys)\n keys ||= User.field_names\n except &&= Array.wrap(except)\n except ||= %i[id email]\n devise_parameter_sanitizer.permit(action, keys: keys, except: except, &blk)\n end",
"def list_params\n if current_user && current_user.role == 'admin'\n params.require(:list).permit(:name, :url, :description, :user_id,\n ideas_attributes: [:id, :list_id, :body, :due_date, :completion_status, :_destroy])\n else\n params.require(:list).permit(:name, :description,\n ideas_attributes: [:body, :due_date, :completion_status]) \n end\n end",
"def whitelist(params)\n send_request_of_type(GlobalConstant::PrivateOpsApi.private_ops_api_type, 'post', '/token-sale/whitelist', params)\n end",
"def valid_access_params\n params.require(:valid_access).permit(:wish_list_id, :user_id)\n end",
"def url_allowlist; end",
"def ensure_redirected_params_are_safe!(passed_params)\n unless passed_params.is_a?(ActionController::Parameters) && passed_params.permitted?\n error_message = if passed_params.is_a?(ActionController::Parameters)\n unsafe_parameters = passed_params.send(:unpermitted_keys, params)\n \"[Rails::Prg] Error - Must use permitted strong parameters. Unsafe: #{unsafe_parameters.join(', ')}\"\n else\n \"[Rails::Prg] Error - Must pass strong parameters.\"\n end\n raise error_message\n end\n end",
"def data_collection_params\n allow = [:name,:description,:institution,:collection_name,:country_id,:province_id,:city_id]\n params.require(:data_collection).permit(allow)\n end",
"def quote_params\n params.permit!\n end"
] | [
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.6326454",
"0.63140553",
"0.6299814",
"0.62642586",
"0.626006",
"0.62578833",
"0.6236823",
"0.6227561",
"0.6221758",
"0.62200165",
"0.620879",
"0.61983657",
"0.6195055",
"0.6172993",
"0.6156856",
"0.61558664",
"0.61521494",
"0.6135789",
"0.6121145",
"0.61118174",
"0.60736513",
"0.6071645",
"0.60632104",
"0.60549796",
"0.6043906",
"0.6034662",
"0.60207325",
"0.6018568",
"0.6016575",
"0.60103434",
"0.60084206",
"0.600763",
"0.6007443",
"0.6003619",
"0.6003619",
"0.5995791",
"0.5993301",
"0.5993231",
"0.5984926",
"0.597122",
"0.5968121",
"0.5965808",
"0.59640145",
"0.59632224",
"0.59602356",
"0.59332967",
"0.5927556",
"0.5922805",
"0.5909745",
"0.5905083",
"0.5904304",
"0.5893434",
"0.58888215",
"0.58823985",
"0.58823985",
"0.58823985",
"0.5873434",
"0.58619875",
"0.58533794",
"0.5845531",
"0.58426666",
"0.58360124",
"0.583218",
"0.5828041",
"0.5827927",
"0.5816121",
"0.5814705",
"0.5812719",
"0.581121",
"0.5803423",
"0.5803423",
"0.57995003",
"0.5794207",
"0.5784923",
"0.5781365",
"0.5776385",
"0.5774859",
"0.57671493",
"0.5766998",
"0.57618684",
"0.5758038"
] | 0.0 | -1 |
Returns the decoder stub that is adjusted for the size of the buffer being encoded. | def decoder_stub(state)
# add one xor operation for the key (see comment below)
number_of_passes=state.buf.length/4+1
raise InvalidPayloadSizeException.new("The payload being encoded is too long (#{state.buf.length} bytes)") if number_of_passes > 10240
raise InvalidPayloadSizeException.new("The payload is not padded to 4-bytes (#{state.buf.length} bytes)") if state.buf.length%4 != 0
# 16-bits not (again, see below)
reg_14 = (number_of_passes+1)^0xFFFF
decoder = Metasm::Shellcode.assemble(Metasm::MIPS.new(:little), <<EOS).encoded.data
;
; MIPS nul-free xor decoder
;
; (C) 2006 Julien TINNES
; <julien at cr0.org>
;
; The first four bytes in encoded shellcode must be the xor key
; This means that you have to put the xor key right after
; this xor decoder
; This key will be considered part of the encoded shellcode
; by this decoder and will be xored, thus becoming 4NULs, meaning nop
;
; This is Linux-only because I use the cacheflush system call
;
; You can use shellforge to assemble this, but be sure to discard all
; the nul bytes at the end (everything after x01\\x4a\\x54\\x0c)
;
; change 2 bytes in the first instruction's opcode with the number of passes
; the number of passes is the number of xor operations to apply, which should be
; 1 (for the key) + the number of 4-bytes words you have in your shellcode
; you must encode ~(number_of_passes + 1) (to ensure that you're nul-free)
;.text
;.align 2
;.globl main
;.ent main
;.type main,@function
main:
li macro reg, imm
; lui reg, ((imm) >> 16) & 0ffffh
; ori reg, reg, (imm) & 0ffffh
addiu reg, $0, imm ; sufficient if imm.abs <= 0x7fff
endm
li( $14, #{reg_14}) ; 4 passes
nor $14, $14, $0 ; put number of passes in $14
li( $11,-73) ; addend to calculated PC is 73
;.set noreorder
next:
bltzal $8, next
;.set reorder
slti $8, $0, 0x8282
nor $11, $11, $0 ; addend in $9
addu $25, $31, $11 ; $25 points to encoded shellcode +4
; addu $16, $31, $11 ; $16 too (enable if you want to pass correct parameters to cacheflush
; lui $2, 0xDDDD ; first part of the xor (old method)
slti $23, $0, 0x8282 ; store 0 in $23 (our counter)
; ori $17, $2, 0xDDDD ; second part of the xor (old method)
lw $17, -4($25) ; load xor key in $17
li( $13, -5)
nor $13, $13, $0 ; 4 in $13
addi $15, $13, -3 ; 1 in $15
loop:
lw $8, -4($25)
addu $23, $23, $15 ; increment counter
xor $3, $8, $17
sltu $30, $23, $14 ; enough loops?
sw $3, -4($25)
addi $6, $13, -1 ; 3 in $6 (for cacheflush)
bne $0, $30, loop
addu $25, $25, $13 ; next instruction to decode :)
; addiu $4, $16, -4 ; not checked by Linux
; li $5,40 ; not checked by Linux
; li $6,3 ; $6 is set above
; .set noreorder
li( $2, 4147) ; cacheflush
;.ascii "\\x01JT\\x0c" ; nul-free syscall
syscall 0x52950
; .set reorder
; write last decoder opcode and decoded shellcode
; li $4,1 ; stdout
; addi $5, $16, -8
; li $6,40 ; how much to write
; .set noreorder
; li $2, 4004 ; write
; syscall
; .set reorder
nop ; encoded shellcoded must be here (xor key right here ;)
; $t9 (aka $25) points here
EOS
# put the key at the end of the decoder
state.decoder_key_offset = decoder.length - 4
return decoder
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decoder_stub(state)\n\t\tif (state.decoder_stub == nil)\n\t\t\tblock = generate_decoder_stub(state) || (raise BadGenerateError)\n\t\t\tstate.decoder_key_offset = block.index('XORK')\n\t\t\tstate.decoder_stub = block\n\t\tend\n\n\t\tstate.decoder_stub\n\tend",
"def decoder_stub(state)\n len = state.buf.length \n\n decoder =\n \"\\xd9\\xee\" +\t\t\t # fldz \n \"\\xd9\\x74\\x24\\xf4\" +\t\t # fnstenv [esp - 0xc]\n \"\\x5f\" +\t\t\t # pop edi\n \"\\x83\\xc7\\x22\" +\t\t # add edi, 0x22\n \"\\x8d\\x37\" +\t\t\t # lea esi, [edi]\n \"\\x83\\xc6\" + [len].pack('C') + \t # add esi, (len + 1)\n \"\\x31\\xc0\" +\t\t\t # xor eax, eax\n \"\\x8a\\x07\" +\t\t\t # mov al, BYTE PTR [edi]\n \"\\x34X\" +\t\t\t # xor al, (xor key)\n \"\\x74\\x0b\" +\t\t\t # je +11 \n \"\\x8d\\x1e\" +\t\t\t # lea ebx, [esi]\n \"\\x01\\xc3\" +\t\t\t # add ebx, eax\n \"\\x8a\\x03\" +\t\t\t # mov al, BYTE PTR [ebx]\n \"\\x88\\x07\" +\t\t\t # mov BYTE PTR [edi], al\n \"\\x47\" +\t\t\t # inc edi\n \"\\xeb\\xef\"\t\t\t # jmp -17\n\n state.decoder_key_offset = 20\n\n return decoder\n end",
"def decoder_stub(state)\n\t\tstate.key = \"\"\n\t\tstate.decoder_key_size = 0\n\t\tRex::Encoder::NonUpper::gen_decoder()\n\tend",
"def buffer_initial_length()\n #This is a stub, used for indexing\n end",
"def decoder_stub(state)\n\t\t[\n\t\t\t0x7ca52a79, # 0x1da4 <main>: xor. r5,r5,r5\n\t\t\t0x4082fffd, # 0x1da8 <main+4>: bnel+ 0x1da4 <main>\n\t\t\t0x7fe802a6, # 0x1dac <main+8>: mflr r31\n\t\t\t0x3bffd00c, # 0x1db0 <main+12>: addi r31,r31,-12276\n\t\t\t0x38a53030, # 0x1db4 <main+16>: addi r5,r5,12336\n\t\t\t0x3cc00102, # 0x1db8 <main+20>: lis r6, hi16(key)\n\t\t\t0x60c60304, # 0x1dbc <main+24>: ori r6,r6, lo16(key)\n\t\t\t0x811f3030, # 0x1dc0 <main+28>: lwz r8,12336(r31)\n\t\t\t0x7d043279, # 0x1dc4 <main+32>: xor. r4,r8,r6\n\t\t\t0x909f3030, # 0x1dc8 <main+36>: stw r4,12336(r31)\n\t\t\t0x7c05f8ac, # 0x1dcc <main+40>: dcbf r5,r31\n\t\t\t0x7cff04ac, # 0x1dd0 <main+44>: sync\n\t\t\t0x7c05ffac, # 0x1dd4 <main+48>: icbi r5,r31\n\t\t\t0x3bc5cfd4, # 0x1dd8 <main+52>: addi r30,r5,-12332\n\t\t\t0x7ffff214, # 0x1ddc <main+56>: add r31,r31,r30\n\t\t\t0x4082ffe0, # 0x1de0 <main+60>: bne+ 0x1dc0 <main+28>\n\t\t\t0x4cff012c, # 0x1de4 <main+64>: isync\n\t\t].pack(\"N*\")\n\tend",
"def buffer_resolution\n @zfactory.buffer_resolution\n end",
"def decode_frame\n raise NotImplementedError\n end",
"def decode\n raise NotImplementedError\n end",
"def decode\n state = :normal\n decoded = buffer.reduce [] do |acc, byte|\n case state\n when :normal\n if byte == 0x7d\n state = :special\n else\n acc << byte\n end\n when :special\n state = :normal\n acc << (byte ^ 0x20)\n end\n acc\n end\n Packet.new decoded\n end",
"def generate_decoder_stub(state)\n\t\tkey_reg = Rex::Poly::LogicalRegister::X86.new('key')\n\t\tendb = Rex::Poly::SymbolicBlock::End.new\n\t\tcld = Rex::Poly::LogicalBlock.new('cld', \"\\xfc\")\n\t\tinit_key = Rex::Poly::LogicalBlock.new('init_key',\n\t\t\tProc.new { |b| (0xb8 + b.regnum_of(key_reg)).chr + 'XORK' })\n\t\tpopeip = Rex::Poly::LogicalBlock.new('popeip', \"\\x5e\")\n\t\tpusheip = Rex::Poly::LogicalBlock.new('pusheip', \"\\x56\")\n\t\txor = Rex::Poly::LogicalBlock.new('xor',\n\t\t\tProc.new { |b| \"\\x31\" + (6 + (8 * b.regnum_of(key_reg))).chr })\n\t\tlodsd = Rex::Poly::LogicalBlock.new('lodsd', \"\\xad\")\n\t\tadd = Rex::Poly::LogicalBlock.new('add',\n\t\t\tProc.new { |b| \"\\x01\" + (0xc0 + b.regnum_of(key_reg)).chr })\n\t\ttest = Rex::Poly::LogicalBlock.new('test', \"\\x85\\xc0\")\n\t\tjnz = Rex::Poly::LogicalBlock.new('jnz',\n\t\t\tProc.new { |b| \"\\x75\" + [ (0x100 - (b.offset_of(b) - b.offset_of(xor) + 2)) ].pack('C') })\n\t\tfin = Rex::Poly::LogicalBlock.new('ret', \"\\xc3\")\n\t\tjmp = Rex::Poly::LogicalBlock.new('jmp')\n\t\tcall = Rex::Poly::LogicalBlock.new('call',\n\t\t\tProc.new { |b| \"\\xe8\" + [ (-(b.offset_of(endb) - (b.offset_of(jmp) + 2))) ].pack('V') })\n\t\tjmp.add_perm(\n\t\t\tProc.new { |b| \"\\xeb\" + [ (b.offset_of(fin) + 1 - (b.offset_of(b) + 2)) ].pack('C') })\n\n\t\t# These blocks can be in lots of different places, but should only be\n\t\t# used once.\n\t\tcld.once = true\n\t\tinit_key.once = true\n\n\t\t# This can be improved by making it so init_key and cld can occur\n\t\t# anywhere prior to pusheip.\n\t\tfin.depends_on(jnz)\n\t\tjnz.depends_on(test)\n\t\ttest.depends_on(add)\n\t\tadd.depends_on(lodsd)\n\t\tlodsd.depends_on(xor)\n\t\txor.depends_on(pusheip)\n\t\tpusheip.depends_on(popeip, init_key, cld)\n\t\tcall.depends_on(fin, init_key, cld)\n\t\tjmp.next_blocks(call)\n\t\tjmp.depends_on(init_key, cld)\n\n\t\tjmp.generate([ \n\t\t\tRex::Arch::X86::ESP, \n\t\t\tRex::Arch::X86::EAX, \n\t\t\tRex::Arch::X86::ESI ], nil, state.badchars)\n\tend",
"def set_decoder\n @decoder = Decoder.find(params[:id])\n end",
"def actual_buffer(offset=0)\n @transfer[:buffer].get_bytes(offset, @transfer[:actual_length])\n end",
"def size\n @size ||= @buffer.size\n end",
"def decode(bytes)\n raise NotImplementedError, \"#{self.class.name}\\#decode\"\n end",
"def decoder(data)\n result = CKB::Utils.hex_to_bin(data).unpack(\"Q<\")[0]\n return result.to_i\nend",
"def decode_video\n Internal::check Internal::rawmedia_decode_video(@decoder,\n @video_buffer_ptr,\n @width_ptr,\n @height_ptr,\n @video_buffer_size_ptr)\n end",
"def decode_val( encoding, size, io )\n # plain string\n if encoding == Protocol::ENCODINGS[:plain]\n io.read_unpacked size, 'a' + size.to_s\n # number\n elsif encoding == Protocol::ENCODINGS[:number]\n io.read_unpacked size, size == 4 ? 'l<' : 'q<'\n else\n raise 'Unknown data encoding.'\n end\n end",
"def unmarshall(buf)\n ret, size = unmarshall_buffer(buf)\n ret\n end",
"def recv_msg(codec, last: false, limit_size: nil)\n data = @transport.read_data(last: last)\n\n raise StopIteration if data.nil?\n\n compressed, size, buf = *data\n\n unless size == buf.size\n raise \"inconsistent data: #{buf}\"\n end\n\n if limit_size && size > limit_size\n raise GrpcKit::Errors::ResourceExhausted, \"Receving message is too large: recevied=#{size}, max=#{limit_size}\"\n end\n\n if compressed\n raise 'compress option is unsupported'\n end\n\n begin\n codec.decode(buf)\n rescue ArgumentError => e\n raise GrpcKit::Errors::Internal, \"Error while decoding in server: #{e}\"\n end\n end",
"def stub\n Ablerc::StubGenerator.new({:options => options}.merge(stub_options))\n end",
"def decode=(_arg0); end",
"def decode=(_arg0); end",
"def alloc_buffer\n ByteArray.new(@block_size)\n end",
"def get_raw_buffer\n @buffer\n end",
"def buffer_initial_length=(length)\n #This is a stub, used for indexing\n end",
"def buffer(size = 4)\n \"\\0\" * size\n end",
"def decode\n unless @buffer\n raise ArgumentError, \"Can't decode, buffer is empty.\"\n end\n struct = @buffer.unpack(\"nZ*Z*\")\n unless struct[0] == 1 or struct[0] == 2\n raise TftpError, \"opcode #{struct[0]} is not a RRQ or WRQ!\"\n end\n @filename = struct[1]\n unless @filename.length > 0\n raise TftpError, \"filename is the null string\"\n end\n @mode = struct[2]\n unless TftpPacketInitial.valid_mode? @mode\n raise TftpError, \"mode #{@mode} is not valid\"\n end\n\n # We need to find the point at which the opcode, filename and mode\n # have ended and the options begin.\n offset = 0\n nulls = []\n @buffer.each_byte do |c|\n nulls.push offset if c == 0\n offset += 1\n end\n # There should be at least 3, the 0 in the opcode, the terminator for\n # the filename, and the terminator for the mode. If there are more,\n # then there are options.\n if nulls.length < 3\n raise TftpError, \"Failed to parse nulls looking for options\"\n elsif nulls.length > 3\n lower_bound = nulls[2] + 1\n @options = decode_options(@buffer[lower_bound..-1])\n end\n\n return self\n end",
"def unmarshall_buffer(buf)\n buf = buf.dup\n if buf[0] == ?l\n endianness = LIL_END\n else\n endianness = BIG_END\n end\n pu = PacketUnmarshaller.new(buf, endianness)\n dummy, @message_type, @flags, @protocol, @body_length, @serial,\n headers = pu.unmarshall(MESSAGE_SIGNATURE)\n headers.each do |struct|\n case struct[0]\n when PATH\n @path = struct[1]\n when INTERFACE\n @interface = struct[1]\n when MEMBER\n @member = struct[1]\n when ERROR_NAME\n @error_name = struct[1]\n when REPLY_SERIAL\n @reply_serial = struct[1]\n when DESTINATION\n @destination = struct[1]\n when SENDER\n @sender = struct[1]\n when SIGNATURE\n @signature = struct[1]\n end\n end\n pu.align(8)\n if @body_length > 0 and @signature\n @params = pu.unmarshall(@signature, @body_length)\n end\n [self, pu.idx]\n end",
"def initialize(encoder, max_size: DEFAULT_MAX_PAYLOAD_SIZE)\n @encoder = encoder\n @max_size = max_size\n end",
"def video_byte_buffer\n Util.wrap_pointer(video_buffer, video_buffer_size)\n end",
"def height\n @grpc.height\n end",
"def buffer_size\n @buffer.size\n end",
"def initialize(buffer_size)\n super()\n @buffer_size = buffer_size\n end",
"def initialize(buf_size)\n @buffer_size = buf_size\n super(buf_size)\n end",
"def parse!(data)\n @buffer += data\n overhang = nil\n\n if @size.nil?\n # parse the length field of the \n # extract 4 bytes length header\n @size = @buffer.slice!(0...4).unpack(\"N\").first if @buffer.size >= 4 \n else\n # envelope is complete and contains overhang\n overhang = @buffer.slice!(@size, @buffer.size) if @buffer.size > @size\n end\n \n overhang\n end",
"def decode; end",
"def decode; end",
"def receive\n begin\n paylaod_length = Protocol::Common::DataTypes::Uint32.decode(@io_in)\n rescue NoMethodError\n nil\n else\n payload = @io_in.read(paylaod_length)\n if payload.nil? || payload.bytesize != paylaod_length\n nil\n else\n payload\n end\n end\n end",
"def decode\n @decode ||= Multihashes.decode([content_addressable].pack('H*'))\n end",
"def bdecode\n @index = 0\n data = []\n while @index < self.length\n data << case self[@index]\n when /\\d/\n decode_str\n when 'l'\n decode_list\n when 'i'\n decode_int\n when 'd'\n decode_dict\n else\n raise ArgumentError, \"Cannot bdecode invalid string.\"\n end\n @index += 1\n end\n @index = 0\n data.length > 1 ? data : data[0]\n end",
"def decompressed_size; end",
"def decrypt_block_size\n (size/8)-1\n end",
"def max_buffer_size=(_arg0); end",
"def h000000000000000000000000000000000000000000010111000110111101eader_udp package_number, file_size, signal=\"send\"\n file_size = \"%0#{@header_file_size}b\" % file_size\n number_package = \"%0#{@header_number_package_size}b\" % package_number\n eof = \"0\" if signal == \"send\"\n eof = \"1\" if signal == \"eof\"\n file_size initialize(socket, address=nil)\n @package_size = 1024\n @address = address\n # @header_package_data = 60\n @header_file_size = 60\n @header_number_package_size = 20\n @header_eof_size = 1\n @header_size = @header_file_size + @header_number_package_size + @header_eof_size\n @oob_char = '!'\n @socket = socket\n end",
"def unpack\n if ! @unpacked && @sec_buffer && @struct\n dataBufferSize, dType, dataBuffer, tokenBufferSize, tType, tokenBuffer = @sec_buffer.unpack(\"LLPLLP\")\n dataBufferSize, dType, dataBuffer, tokenBufferSize, tType, tokenBuffer = @sec_buffer.unpack(\"LLP#{dataBufferSize}LLP#{tokenBufferSize}\")\n # Form the buffer stream as required by server\n @buffer = [tokenBufferSize].pack(\"L\")\n @buffer << tokenBuffer << dataBuffer\n @struct = nil\n @sec_buffer = nil\n @unpacked = true\n end\n end",
"def max_buffer_size; end",
"def decode_residual(cursor, cursor_bits, bits_per_sample, block_size, predictor_order, nbr_encoded_partitions)\n method_id, cursor, cursor_bits = decode_bits(cursor, cursor_bits, 2)\n\n invalid_data(\"@#{cursor},#{cursor_bits} - Invalid Residual method id: #{method_id}\") if (method_id > 1)\n rice_parameter_size = 4 + method_id\n partition_order, cursor, cursor_bits = decode_bits(cursor, cursor_bits, 4)\n log_debug \"@#{cursor},#{cursor_bits} - Found residual with method_id=#{method_id} rice_parameter_size=#{rice_parameter_size} partition_order=#{partition_order}\"\n nbr_partitions = 2**partition_order\n nbr_partitions.times do |idx_partition|\n log_debug \"@#{cursor},#{cursor_bits} - Decode partition\"\n rice_parameter, cursor, cursor_bits = decode_bits(cursor, cursor_bits, rice_parameter_size)\n partition_bits_per_sample, cursor, cursor_bits = decode_bits(cursor, cursor_bits, 5) if (rice_parameter == 15)\n nbr_samples = nil\n if (partition_order == 0)\n nbr_samples = block_size - predictor_order\n elsif (nbr_encoded_partitions > 0)\n nbr_samples = block_size / nbr_partitions\n else\n nbr_samples = (block_size / nbr_partitions) - predictor_order\n end\n log_debug \"@#{cursor},#{cursor_bits} - Begin decoding Rice samples: rice_parameter=#{rice_parameter} partition_bits_per_sample=#{partition_bits_per_sample} nbr_samples=#{nbr_samples}\"\n if (partition_bits_per_sample == nil)\n # Samples encoded using Unary high values and rice_parameter length low values.\n # See http://www.hydrogenaudio.org/forums//lofiversion/index.php/t81718.html\n cursor, cursor_bits = decode_rice(cursor, cursor_bits, nbr_samples, rice_parameter)\n # Ruby version, very slow\n # nbr_samples.times do |idx_sample|\n\n # # DEBUG only\n # # value_high, cursor, cursor_bits = decode_unary(cursor, cursor_bits)\n # # value_low, cursor, cursor_bits = decode_bits(cursor, cursor_bits, rice_parameter)\n # # value = ((value_high-1) << (rice_parameter-1)) + (value_low >> 1)\n # # value = -value-1 if (value_low.odd?)\n # # log_debug \"@#{cursor},#{cursor_bits} - Residual[#{idx_sample}]=#{value}\"\n # # NON DEBUG only\n # _, cursor, cursor_bits = decode_unary(cursor, cursor_bits)\n # _, cursor, cursor_bits = decode_bits(cursor, cursor_bits, rice_parameter)\n\n # end\n else\n # Fixed-size encoded samples\n cursor, cursor_bits = inc_cursor_bits(cursor, cursor_bits, nbr_samples * partition_bits_per_sample)\n end\n nbr_encoded_partitions += 1\n progress(cursor)\n end\n\n return cursor, cursor_bits, nbr_encoded_partitions\n end",
"def build_response_packet\n rpacket = RCon::Packet::Source.new\n total_size = 0\n request_id = 0\n type = 0\n response = \"\"\n message = \"\"\n message2 = \"\"\n\n tmp = @socket.recv(4)\n if tmp.nil?\n return nil\n end\n size = tmp.unpack(\"V1\")\n tmp = @socket.recv(size[0])\n request_id, type, message, message2 = tmp.unpack(\"V1V1a*a*\")\n total_size = size[0]\n \n #puts \"size: \"+size.to_s \n #puts \"type: \"+type.to_s\n #puts \"message: \"+message\n #puts \"message2: \"+message2\n \n rpacket.packet_size = total_size\n rpacket.request_id = request_id\n rpacket.command_type = type\n \n # strip nulls (this is actually the end of string1 and string2)\n message.sub! /\\x00\\x00$/, \"\"\n message2.sub! /\\x00\\x00$/, \"\"\n rpacket.string1 = message\n rpacket.string2 = message2\n return rpacket\n end",
"def encode\n [@size].pack(\"N\") + @buffer\n end",
"def decoder_params\n params.require(:decoder).permit(:name)\n end",
"def render_decode_from_body(out, var, type, declared_variables:, self_encode:)\n tail = <<-EOS.strip_heredoc\n n += nTmp\n if err != nil {\n return n, fmt.Errorf(\"decoding #{name type}: %s\", err)\n }\n EOS\n optional = type.sub_type == :optional\n if optional\n render_variable_declaration(out, \" \", 'b', \"bool\", declared_variables: declared_variables)\n out.puts \" b, nTmp, err = d.DecodeBool()\"\n out.puts tail\n out.puts \" #{var} = nil\"\n out.puts \" if b {\"\n out.puts \" #{var} = new(#{name type})\"\n end\n case type\n when AST::Typespecs::UnsignedHyper\n out.puts \" #{var}, nTmp, err = d.DecodeUhyper()\"\n out.puts tail\n when AST::Typespecs::Hyper\n out.puts \" #{var}, nTmp, err = d.DecodeHyper()\"\n out.puts tail\n when AST::Typespecs::UnsignedInt\n out.puts \" #{var}, nTmp, err = d.DecodeUint()\"\n out.puts tail\n when AST::Typespecs::Int\n out.puts \" #{var}, nTmp, err = d.DecodeInt()\"\n out.puts tail\n when AST::Typespecs::Bool\n out.puts \" #{var}, nTmp, err = d.DecodeBool()\"\n out.puts tail\n when AST::Typespecs::String\n arg = \"0\"\n arg = type.decl.resolved_size unless type.decl.resolved_size.nil?\n out.puts \" #{var}, nTmp, err = d.DecodeString(#{arg})\"\n out.puts tail\n when AST::Typespecs::Opaque\n if type.fixed?\n out.puts \" nTmp, err = d.DecodeFixedOpaqueInplace(#{var}[:])\"\n out.puts tail\n else\n arg = \"0\"\n arg = type.decl.resolved_size unless type.decl.resolved_size.nil?\n out.puts \" #{var}, nTmp, err = d.DecodeOpaque(#{arg})\"\n out.puts tail\n end\n when AST::Typespecs::Simple\n case type.sub_type\n when :simple, :optional\n optional_within = type.is_a?(AST::Identifier) && type.resolved_type.sub_type == :optional\n if optional_within\n render_variable_declaration(out, \" \", 'b', \"bool\", declared_variables: declared_variables)\n out.puts \" b, nTmp, err = d.DecodeBool()\"\n out.puts tail\n out.puts \" #{var} = nil\"\n out.puts \" if b {\"\n out.puts \" #{var} = new(#{name type.resolved_type.declaration.type})\"\n end\n var = \"(*#{name type})(#{var})\" if self_encode\n out.puts \" nTmp, err = #{var}.DecodeFrom(d)\"\n out.puts tail\n if optional_within\n out.puts \" }\"\n end\n when :array\n out.puts \" for i := 0; i < len(#{var}); i++ {\"\n element_var = \"#{var}[i]\"\n optional_within = type.is_a?(AST::Identifier) && type.resolved_type.sub_type == :optional\n if optional_within\n out.puts \" var eb bool\"\n out.puts \" eb, nTmp, err = d.DecodeBool()\"\n out.puts tail\n out.puts \" #{var} = nil\"\n out.puts \" if eb {\"\n var = \"(*#{element_var})\"\n end\n out.puts \" nTmp, err = #{element_var}.DecodeFrom(d)\"\n out.puts tail\n if optional_within\n out.puts \" }\"\n end\n out.puts \" }\"\n when :var_array\n render_variable_declaration(out, \" \", 'l', \"uint32\", declared_variables: declared_variables)\n out.puts \" l, nTmp, err = d.DecodeUint()\"\n out.puts tail\n unless type.decl.resolved_size.nil?\n out.puts \" if l > #{type.decl.resolved_size} {\"\n out.puts \" return n, fmt.Errorf(\\\"decoding #{name type}: data size (%d) exceeds size limit (#{type.decl.resolved_size})\\\", l)\"\n out.puts \" }\"\n end\n out.puts \" #{var} = nil\"\n out.puts \" if l > 0 {\"\n out.puts \" #{var} = make([]#{name type}, l)\"\n out.puts \" for i := uint32(0); i < l; i++ {\"\n element_var = \"#{var}[i]\"\n optional_within = type.is_a?(AST::Identifier) && type.resolved_type.sub_type == :optional\n if optional_within\n out.puts \" var eb bool\"\n out.puts \" eb, nTmp, err = d.DecodeBool()\"\n out.puts tail\n out.puts \" #{element_var} = nil\"\n out.puts \" if eb {\"\n out.puts \" #{element_var} = new(#{name type.resolved_type.declaration.type})\"\n var = \"(*#{element_var})\"\n end\n out.puts \" nTmp, err = #{element_var}.DecodeFrom(d)\"\n out.puts tail\n if optional_within\n out.puts \" }\"\n end\n out.puts \" }\"\n out.puts \" }\"\n else\n raise \"Unknown sub_type: #{type.sub_type}\"\n end\n when AST::Definitions::Base\n if self_encode\n out.puts \" nTmp, err = #{name type}(#{var}).DecodeFrom(d)\"\n else\n out.puts \" nTmp, err = #{var}.DecodeFrom(d)\"\n end\n out.puts tail\n else\n out.puts \" nTmp, err = d.Decode(&#{var})\"\n out.puts tail\n end\n if optional\n out.puts \" }\"\n end\n end",
"def decode\n transform :decode\n end",
"def extended_payload_length\n # 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n # +-+-+-+-+-------+-+-------------+-------------------------------+\n # |F|R|R|R| opcode|M| Payload len | Extended payload length |\n # |I|S|S|S| (4) |A| (7) | (16/64) |\n # |N|V|V|V| |S| | (if payload len==126/127) |\n # | |1|2|3| |K| | |\n # +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +\n # | Extended payload length continued, if payload len == 127 |\n # + - - - - - - - - - - - - - - - +-------------------------------+\n # | |Masking-key, if MASK set to 1 |\n # +-------------------------------+-------------------------------+\n data = get\n case @need\n when 2\n @payload_length = data.unpack(\"S>\").first\n when 8\n @payload_length = data.unpack(\"Q>\").first\n else\n raise \"Unknown payload_length byte length '#{@need}'\"\n end\n\n if @masked\n # Read the mask next if there is one.\n transition(:mask, 4)\n else\n # Otherwise, next is the payload\n transition(:payload, @payload_length)\n end\n\n # This state yields no output.\n return nil\n end",
"def getbyte()\n #This is a stub, used for indexing\n end",
"def msg_size; @msg_size ||= PackedHeader.new(4, 'N'); end",
"def generate(frame)\n bytes = Buffer.new\n length = 0\n\n frame[:flags] ||= []\n frame[:stream] ||= 0\n\n case frame[:type]\n when :data\n bytes << frame[:payload]\n length += frame[:payload].bytesize\n\n when :headers\n if frame[:priority]\n frame[:flags] += [:priority] if !frame[:flags].include? :priority\n end\n\n if frame[:flags].include? :priority\n bytes << [frame[:priority] & RBIT].pack(UINT32)\n length += 4\n end\n\n bytes << frame[:payload]\n length += frame[:payload].bytesize\n\n when :priority\n bytes << [frame[:priority] & RBIT].pack(UINT32)\n length += 4\n\n when :rst_stream\n bytes << pack_error(frame[:error])\n length += 4\n\n when :settings\n if frame[:stream] != 0\n raise CompressionError.new(\"Invalid stream ID (#{frame[:stream]})\")\n end\n\n frame[:payload].each do |(k,v)|\n if !k.is_a? Integer\n k = DEFINED_SETTINGS[k]\n\n if k.nil?\n raise CompressionError.new(\"Unknown settings ID for #{k}\")\n end\n end\n\n bytes << [k & RBYTE].pack(UINT32)\n bytes << [v].pack(UINT32)\n length += 8\n end\n\n when :push_promise\n bytes << [frame[:promise_stream] & RBIT].pack(UINT32)\n bytes << frame[:payload]\n length += 4 + frame[:payload].bytesize\n\n when :ping\n if frame[:payload].bytesize != 8\n raise CompressionError.new(\"Invalid payload size \\\n (#{frame[:payload].size} != 8 bytes)\")\n end\n bytes << frame[:payload]\n length += 8\n\n when :goaway\n bytes << [frame[:last_stream] & RBIT].pack(UINT32)\n bytes << pack_error(frame[:error])\n length += 8\n\n if frame[:payload]\n bytes << frame[:payload]\n length += frame[:payload].bytesize\n end\n\n when :window_update\n bytes << [frame[:increment] & RBIT].pack(UINT32)\n length += 4\n\n when :continuation\n bytes << frame[:payload]\n length += frame[:payload].bytesize\n end\n\n frame[:length] = length\n bytes.prepend(commonHeader(frame))\n end",
"def decode\n @msglen = plain_text.length\n holes = compute_holes(@msglen)\n\n end",
"def deserialize(buffer)\n return unless (buffer)\n \n data = buffer.unpack(\"nnnnnn\")\n \n # Abandon efforts to decode if insufficient data is available.\n return if (data.length < 6)\n \n self.id = data.shift\n\n flags = data.shift\n self.query = (flags & 0x8000 == 0)\n self.opcode = ReDNS::OPCODE_LABEL[(flags & 0x7800) >> 12]\n self.authorative = (flags & 0x0400 != 0)\n self.truncated = (flags & 0x0200 != 0)\n self.recursion_desired = (flags & 0x0100 != 0)\n self.recursion_available = (flags & 0x0080 != 0)\n self.response_code = ReDNS::RCODE_LABEL[flags & 0x000F]\n \n SECTIONS.each do |section|\n @attributes[:\"#{section}_count\"] = data.shift\n end\n \n SECTIONS.each do |section|\n collection = @attributes[section] = [ ]\n \n decode_class =\n case (section)\n when :questions\n ReDNS::Question\n else\n ReDNS::Resource\n end\n \n @attributes[:\"#{section}_count\"].times do\n collection << decode_class.new(buffer)\n end\n end\n \n self\n end",
"def default_protocol_envelope_size(protocol_version)\n protocol_version > '2.1' ? 512000 : 153600\n end",
"def size\n @buffer.size\n end",
"def size\n @buffer.size\n end",
"def size\n @buffer.size\n end",
"def bdecode\n BEncode.load(self)\n end",
"def get_ber(msg)\n ber = client.railgun.memread(msg[2],60).unpack('V*')\n\n # BER Pointer is different between x86 and x64\n if client.arch == ARCH_X64\n ber_data = client.railgun.memread(ber[4], ber[0])\n else\n ber_data = client.railgun.memread(ber[3], ber[0])\n end\n\n return ber_data\n end",
"def interpret_size(size); end",
"def size\n to_payload.bytesize\n end",
"def remainder_as_buffer; end",
"def replay\n buf = read\n @size += @format.parse(buf, &@emit)\n end",
"def reply\n bytes_read = receive_packet 1400\n is_compressed = false\n\n if @buffer.long == 0xFFFFFFFE\n split_packets = []\n begin\n # Parsing of split packet headers\n request_id = @buffer.long\n is_compressed = ((request_id & 0x80000000) != 0)\n packet_count = @buffer.byte\n packet_number = @buffer.byte + 1\n\n if is_compressed\n @buffer.long\n packet_checksum = @buffer.long\n else\n @buffer.short\n end\n\n # Caching of split packet data\n split_packets[packet_number - 1] = @buffer.get\n\n puts \"Received packet #{packet_number} of #{packet_count} for request ##{request_id}\" if $DEBUG\n\n # Receiving the next packet\n if split_packets.size < packet_count\n begin\n bytes_read = receive_packet\n rescue TimeoutException\n bytes_read = 0\n end\n else\n bytes_read = 0\n end\n end while bytes_read > 0 && @buffer.long == 0xFFFFFFFE\n\n if is_compressed\n packet = SteamPacketFactory.reassemble_packet(split_packets, true, packet_checksum)\n else\n packet = SteamPacketFactory.reassemble_packet(split_packets)\n end\n else\n packet = SteamPacketFactory.packet_from_data(@buffer.get)\n end\n\n if is_compressed\n puts \"Got compressed reply of type \\\"#{packet.class.to_s}\\\".\" if $DEBUG\n else\n puts \"Got reply of type \\\"#{packet.class.to_s}\\\".\" if $DEBUG\n end\n\n packet\n end",
"def encode_finalize_stub(state, stub)\n\t\tstub[22, 2] = [ state.key.to_i ].pack('N')[0, 2]\n\t\tstub[26, 2] = [ state.key.to_i ].pack('N')[2, 2]\n\n\t\tstub\n\tend",
"def data_len_bytes()\n 2\n end",
"def data_len_bytes()\n 2\n end",
"def data_len_bytes()\n 2\n end",
"def reply\n receive_packet 1400\n is_compressed = false\n packet_checksum = 0\n\n if @buffer.long == 0xFFFFFFFE\n split_packets = []\n begin\n request_id = @buffer.long\n is_compressed = ((request_id & 0x80000000) != 0)\n packet_count = @buffer.getbyte\n packet_number = @buffer.getbyte + 1\n\n if is_compressed\n @buffer.long\n packet_checksum = @buffer.long\n else\n @buffer.short\n end\n\n split_packets[packet_number - 1] = @buffer.get\n\n log.debug \"Received packet #{packet_number} of #{packet_count} for request ##{request_id}\"\n\n bytes_read = 0\n if split_packets.size < packet_count\n begin\n bytes_read = receive_packet\n rescue SteamCondenser::Error::Timeout\n end\n end\n end while bytes_read > 0 && @buffer.long == 0xFFFFFFFE\n\n packet = SteamCondenser::Servers::Packets::SteamPacketFactory.reassemble_packet(split_packets, is_compressed, packet_checksum)\n else\n packet = SteamCondenser::Servers::Packets::SteamPacketFactory.packet_from_data(@buffer.get)\n end\n\n if log.debug?\n packet_class = packet.class.name[/[^:]*\\z/]\n if is_compressed\n log.debug \"Got compressed reply of type \\\"#{packet_class}\\\".\"\n else\n log.debug \"Got reply of type \\\"#{packet_class}\\\".\"\n end\n end\n\n packet\n end",
"def deserialize(bytes)\n raise \"Invalid byte count: #{bytes}. Expected length of #{length}\" if bytes.length != length\n deserialize_implementation(bytes)\n end",
"def orig_len\n @orig_len || incl_len\n end",
"def bytesize\n stream_size\n end",
"def test_plain_respects_bufsize\n\n resolver = Resolver.new('a.gtld-servers.net')\n resolver.query_timeout=20\n\n run_test = ->(bufsize) do\n\n\n create_test_query = ->(bufsize) do\n message = Message.new('com', Types.RRSIG, Classes.IN)\n message.add_additional(RR::OPT.new(bufsize))\n message\n end\n\n query = create_test_query.(bufsize)\n response, _error = resolver.send_plain_message(query)\n if (_error != nil) then\n print \"Error at #{bufsize} : #{_error}\"\n end\n# puts \"\\nBufsize is #{bufsize}, binary message size is #{response.encode.size}\"\n assert_equal(true, response.header.tc)\n assert(response.encode.size <= bufsize)\n end\n\n run_test.(612)\n end",
"def byte_rate\n Rational(size,duration)\n end",
"def getk_response_from_buffer(buf)\n # There's no header in the buffer, so don't advance\n return [0, nil, nil, nil, nil] unless contains_header?(buf)\n\n tokens, header_len, body_len = tokens_from_header_buffer(buf)\n\n # We have a complete response that has no body.\n # This is either the response to the terminating\n # noop or, if the status is not MN, an intermediate\n # error response that needs to be discarded.\n return [header_len, true, nil, nil, nil] if body_len.zero?\n\n resp_size = header_len + body_len + TERMINATOR.length\n # The header is in the buffer, but the body is not. As we don't have\n # a complete response, don't advance the buffer\n return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size\n\n # The full response is in our buffer, so parse it and return\n # the values\n body = buf.slice(header_len, body_len)\n full_response_from_buffer(tokens, body, resp_size)\n end",
"def byte_size(); @data.byte_size + 4; end",
"def uncompressed_size\n @deflater.closed? ? @uncompressed_size : @deflater.total_in\n end",
"def uncompressed_size\n @header.size\n end",
"def read_frame\n byte = read_and_unpack_byte\n fin = (byte & 0b10000000) == 0b10000000\n rsv1 = byte & 0b01000000\n rsv2 = byte & 0b00100000\n rsv3 = byte & 0b00010000\n opcode = byte & 0b00001111\n\n @logger.debug \"unexpected value: rsv1: #{rsv1}\" unless rsv1 == 0\n @logger.debug \"unexpected value: rsv2: #{rsv2}\" unless rsv2 == 0\n @logger.debug \"unexpected value: rsv3: #{rsv3}\" unless rsv3 == 0\n\n byte = read_and_unpack_byte\n mask = (byte & 0b10000000) == 0b10000000\n lenflag = byte & 0b01111111\n\n # if len <= 125, this is the length\n # if len == 126, length is encoded on next two bytes\n # if len == 127, length is encoded on next eight bytes\n len = case lenflag\n when 126 # 2 bytes\n bytes = @sock.read(2)\n len = bytes.unpack(\"n\")[0]\n when 127 # 8 bytes\n bytes = @sock.read(8)\n len = bytes.unpack(\"Q\")[0]\n else\n lenflag\n end\n\n if mask then\n masking_key = @sock.read(4).unpack(\"C*\")\n end\n\n payload = @sock.read(len)\n payload = apply_mask(payload, masking_key) if mask\n\n return fin, opcode, mask, len, masking_key, payload\n end",
"def pay_size_enc(total_size)\n\t#The 32 here is for the 4 added bytes denoting the total size of the payload\n\tsize_signature = (8 * total_size + 32).to_s(2) #8 for bits per byte\n\n\t#Pad 0's here I think(bad commenting)\n\tsize_signature = ((\"0\" * (32 - size_signature.size)) + size_signature).split('')\nend",
"def decode(&block)\n @stream.each_frame(&block)\n end",
"def get_height(*params); raise('Stub or mock required.') end",
"def buffer_info\n @buffer_info ||= BufferInfo.new\n end",
"def calculate_buffer\n raise(RuntimeError, \"An audio file containing data must be opened first.\") unless \n @state.file_byte_size && @state.file_byte_size > 0\n \n out_buffer_size, num_packets = self.class.calculate_buffer_for(\n @state.format_sample_rate, @state.format_frames_per_packet, @state.format_max_packet_size, buffer_seconds)\n \n out_num_packets_to_read = num_packets > @state.file_total_packets ? \n @state.file_total_packets : num_packets\n \n @state.buffer_byte_size, @state.num_packets_to_read = out_buffer_size, out_num_packets_to_read\n end",
"def response\n buffer_available_data\n @buffer[@cursor..-1]\n end",
"def pump #:nodoc:\n len = @buffer.length\n len4 = len - (len % 4)\n @pump_proc.call( Base64.decode64 @buffer[0...len4] ) if len4 > 0\n @buffer = @buffer[len4..-1]\n end",
"def data_len_bytes()\n 1\n end",
"def size\n chunk_size = nil\n File.open(@file_name) do |file|\n file.seek(@offset + 4, IO::SEEK_CUR)\n case @size_length\n when 4\n chunk_size = file.read(@size_length).unpack('L').first\n when 2\n chunk_size = file.read(@size_length).unpack('S').first\n else\n raise \"Can't decode size field of length #{@size_length}\"\n end\n end\n chunk_size + @data_size_correction\n end",
"def read_ber_length\n n = getbyte\n\n if n <= 0x7f\n n\n elsif n == 0x80\n -1\n elsif n == 0xff\n raise Net::BER::BerError, \"Invalid BER length 0xFF detected.\"\n else\n v = 0\n read(n & 0x7f).each_byte do |b|\n v = (v << 8) + b\n end\n\n v\n end\n end",
"def size_in_bytes\n @grpc.size_bytes\n end",
"def bytesize\n not_implemented\n end",
"def bytes\n self\n end",
"def decode_response(buf)\n reply = Resolv::DNS::Message.decode buf\n results = []\n reply.each_answer do |name, _ttl, data|\n if name.to_s =~ /^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(.+)$/\n ip = [Regexp.last_match(4),\n Regexp.last_match(3),\n Regexp.last_match(2),\n Regexp.last_match(1)].join '.'\n domain = Regexp.last_match 5\n @dnsbls.each do |dnsblname, config|\n next unless data.is_a? Resolv::DNS::Resource::IN::A\n next unless domain == config['domain']\n\n meaning = config[data.address.to_s] || data.address.to_s\n results << DNSBLResult.new(dnsblname, ip, name.to_s, data.address.to_s, meaning, Time.now.to_f - @starttime)\n break\n end\n else\n @dnsbls.each do |dnsblname, config|\n next unless name.to_s.end_with? config['domain']\n\n meaning = if config['decoder']\n send \"#{config['decoder']}_decoder\".to_sym, data.address.to_s\n elsif config[data.address.to_s]\n config[data.address.to_s]\n else\n data.address.to_s\n end\n\n results << DNSBLResult.new(dnsblname, name.to_s.gsub(\".#{config['domain']}\", ''),\n name.to_s,\n data.address.to_s,\n meaning,\n Time.now.to_f - @starttime)\n break\n end\n end\n end\n results\n end",
"def decode_string(raw, offset=0)\n if raw.bytesize < offset + 4\n raise DecodeError, \"data too short\"\n end\n\n size_s = raw.byteslice(offset, 4)\n\n size = size_s.unpack(\"L>\").first\n\n if raw.bytesize < offset + 4 + size\n raise DecodeError, \"data too short\"\n end\n\n string = raw.byteslice(offset + 4, size)\n\n [string, 4 + size]\n end",
"def build_decoders(base_decoders=DEFAULT_DECODERS, base_handler=nil)\n all_chain, decoders = [], {}\n decoders_values.each do |value|\n case value\n when Proc\n decoders.each_value{|chain| chain << value }\n all_chain << value\n when Symbol\n decoders[value] = all_chain.dup\n end\n end\n base_decoders.each{|decoder| decoders[decoder] = all_chain.dup } if decoders.empty?\n decoders\n end"
] | [
"0.69858676",
"0.6581347",
"0.6360701",
"0.54129624",
"0.5331713",
"0.5296336",
"0.5275721",
"0.5110416",
"0.50310355",
"0.49725616",
"0.49459594",
"0.4922418",
"0.4910436",
"0.490991",
"0.48910376",
"0.48803258",
"0.48755118",
"0.4873656",
"0.48458695",
"0.48404115",
"0.4832615",
"0.4832615",
"0.4832111",
"0.48198706",
"0.48161027",
"0.48142964",
"0.48082185",
"0.47937804",
"0.4788767",
"0.47879788",
"0.4786235",
"0.478409",
"0.4782395",
"0.47607222",
"0.4756395",
"0.47467116",
"0.47467116",
"0.4743474",
"0.47156778",
"0.47102523",
"0.47049826",
"0.46932656",
"0.4692965",
"0.46580952",
"0.46548662",
"0.4651151",
"0.46396387",
"0.46280745",
"0.46176597",
"0.46095425",
"0.45940414",
"0.4590012",
"0.4585469",
"0.458426",
"0.4570664",
"0.45681426",
"0.45581293",
"0.45509657",
"0.4539024",
"0.45366928",
"0.45366928",
"0.45366928",
"0.4526762",
"0.45235685",
"0.45218086",
"0.45143828",
"0.45101893",
"0.45090505",
"0.44908664",
"0.4490675",
"0.44873103",
"0.44869497",
"0.44869497",
"0.44815338",
"0.44809067",
"0.4473978",
"0.44729313",
"0.44671798",
"0.44649115",
"0.4459694",
"0.44414356",
"0.44330207",
"0.44311157",
"0.44297683",
"0.44269827",
"0.44210985",
"0.44113716",
"0.44101503",
"0.44016117",
"0.4400412",
"0.4398645",
"0.4391722",
"0.43892935",
"0.43756092",
"0.43746793",
"0.43745792",
"0.43697253",
"0.43687555",
"0.4366839",
"0.4365623"
] | 0.521334 | 7 |
Merges this query list with another. The returned query list queries for the intersection between the two inputs. Both query lists should be resolved. | def merge(other)
new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact
return if new_queries.empty?
QueryList.new(new_queries)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersect(other)\n\t\t\tc = Xmms::Collection.new(Xmms::Collection::TYPE_INTERSECTION)\n\t\t\tc.operands << self\n\t\t\tc.operands << other\n\t\t\tc\n\t\tend",
"def intersect(other)\n set_operation(other, :intersect, distinct: true)\n end",
"def intersect(results_list)\n intersection_hits = self.all & results_list.all\n keywords = used_keywords | results_list.used_keywords\n \n ResultsList.new(intersection_hits, keywords.uniq)\n end",
"def intersectLists(iLst1, iLst2)\n rLstIntersection = nil\n\n if (iLst1.empty?)\n if (iLst2.empty?)\n # Add all\n rLstIntersection = []\n else\n rLstIntersection = iLst2\n end\n else\n if (iLst2.empty?)\n rLstIntersection = iLst1\n else\n # Filter\n rLstIntersection = []\n iLst1.each do |iObject|\n if (iLst2.include?(iObject))\n rLstIntersection << iObject\n end\n end\n if (rLstIntersection.empty?)\n rLstIntersection = nil\n end\n end\n end\n\n return rLstIntersection\n end",
"def intersection(other)\n self.class.from_a(to_a & other.to_a)\n end",
"def intersect_all(other)\n set_operation(other, :intersect, distinct: false)\n end",
"def intersect(other)\n intersections(other)\n .with_object(self.class.new) { |(b, e), a| a << create_item(b, e) }\n end",
"def intersection\n self.reduce(&:intersection)\n end",
"def intersection_of left, right\n # Using sorts may be more efficient on large sets.\n right.inject([]) { |intersect, r|\n # The select could be made more efficient.\n matches = left.select { |l| l[\"id\"] == r[\"id\"] }\n intersect.push(matches.first) if matches.any?\n intersect\n }\n end",
"def intersect(other)\n new(to_ary & other)\n end",
"def intersection(other)\n raise ArgumentError, \"value must be a #{self.class.name}\" unless other.is_a?(VersionRange)\n result = @ranges.map { |range| other.ranges.map { |o_range| range.intersection(o_range) } }.flatten\n result.compact!\n result.uniq!\n result.empty? ? EMPTY_RANGE : VersionRange.new(result, nil)\n end",
"def intersect(other)\n Intersection.new(self, other)\n end",
"def intersect(other)\n set = MyHashSet.new\n to_a.each { |el| set.insert(el) if other.include?(el) }\n set\n end",
"def intersection(a, b)\n negate(union(negate(a), negate(b)))\n end",
"def &(other_list)\n intersection_list = self.class.new\n self.list.each do |item, int_value|\n if other_list.list.any?{|other_item, other_value| other_item.equal?(item)}\n intersection_list.list[item] = int_value\n end\n end\n\n return intersection_list\n end",
"def and other_result\n result = dup\n result.matched = hash_intersection(matched, other_result.matched)\n result.not_matched = hash_intersection(not_matched, other_result.not_matched)\n result\n end",
"def intersection(other_set)\n new_set = []\n # Fill our empty array with elements that are members of both sets\n other_set.set.each do |element|\n new_set.push(element) if @set.include?(element)\n end\n Set.new(new_set)\n end",
"def intersection(list1, list2)\n return nil if list1 == nil || list2 == nil\n\n # Each integer is a key in a hash with value 'true'\n hash = {}\n list1.each do |element|\n hash[element] = true\n end\n\n # Check if an integer from the second list is already in a hash\n result = []\n list2.each do |number|\n if hash[number]\n result << number\n end\n end\n\n return result\nend",
"def intersection(other)\n mapping_function = 'lambda{|item| [item, nil]}'\n filter_function = 'lambda{|(key, values)| values.size > 1}'\n\n self.map(mapping_function)\n .cogroup(other.map(mapping_function))\n .filter(filter_function)\n .keys\n end",
"def intersections(list_a, list_b)\n list_a & list_b\nend",
"def intersection(nums1, nums2)\n nums1 & nums2\n end",
"def intersection(set1, set2)\r\n\t# set1 and set2 are arrays\r\n\t# return the intersection\r\nend",
"def intersect(xs, ys)\n result = []\n result = xs & ys\n puts result\nend",
"def intersection(set1, set2)\n # p set1\n # p set2\n intarray=[]\n for object in set1 #for each object in set1\n # p object\n if set2.include?(object) #check if the object is included in set2\n intarray.push(object) #if it is then push it to intarray\n end\n end\n return intarray\n\t# set1 and set2 are arrays\n\t# return the intersection\nend",
"def fetch_intersection(json_a, json_b)\n return json_b.kind_of?(Array) ? json_a & json_b : json_a.intersection(json_b)\n end",
"def *(rhs)\n intersection(rhs)\n end",
"def merge(other)\n other.each { |entry| self << entry }\n self\n end",
"def merge(other)\n if self.overlaps?(other)\n [self | other]\n else\n [self, other]\n end\n end",
"def intersect(other)\n begin_at = self.begin >= other.begin ? self.begin : other.begin\n end_at = self.end <= other.end ? self.end : other.end\n\n begin_at <= end_at ? self.class.new(begin_at..end_at) : nil\n end",
"def subquery\n subqueries.\n compact.\n inject(&:merge)\n end",
"def merge_query\n\t\t\tp = []\n\t\t\tp << @params.query_string unless @params.query_string == \"\"\n\t\t\tp << @filters.query_string unless @filters.query_string == \"\"\n\t\t\treturn p.size > 0 ? p.join(\"&\") : nil\n\t\tend",
"def +(other)\n combined_query = JupiterCore::DeferredSimpleSolrQuery.new(nil)\n combined_query.children.<< self\n combined_query.children << other\n\n combined_query\n end",
"def intersection(list1, list2) \n # edge case\n return [] if list1.empty? || list2.empty?\n\n hash = {} \n result = []\n\n list1.each do |num| \n hash[num] = true \n end \n\n list2.each do |num| \n result << num if hash[num] \n end \n\n return result\nend",
"def intersection(*args)\n other = coerce_range(*args)\n sorted = [self, other].sort\n\n return nil if self.class.compare(sorted[0].end, sorted[1].begin) < 0\n\n ARange[sorted[1].begin, self.class.min(sorted[1].end, sorted[0].end)]\n end",
"def merge(other)\n other.inject(self) { |result, entry| result << entry }\n end",
"def merge(other)\n append(*other)\n end",
"def intersection(other_set)\n requires_set(other_set, __method__)\n other_set.reduce([]) do |array, k|\n array << k if @internal_hash[k]\n array\n end\n end",
"def intersect _obj, _args\n \"_obj intersect _args;\" \n end",
"def intersection(list1, list2) \n hash_check = {}\n list1.each do |num|\n hash_check[num] = true\n end\n \n result = []\n list2.each do |i|\n if hash_check[i] == true\n result << i \n end \n end \n return result\nend",
"def intersection\n @grpc.intersection\n end",
"def intersection_with(other)\n r1,r2 = matched_range_types(self, other)\n max_begin = [r1.begin,r2.begin].max\n min_end = [r1.end, r2.end ].min\n excl = ( r1.end == min_end && \n r1.respond_to?(:exclude_end?) && r1.exclude_end?\n ) ||\n ( r2.end == min_end && \n r2.respond_to?(:exclude_end?) && r2.exclude_end?\n )\n unless max_begin > min_end\n Range.new(max_begin, min_end, excl).extend(DateTimeRange)\n end\n end",
"def set_intersection set1, set2 \n\tresult \t\t\t= [];\n\tsec_index = 0 \n\tfirst_index = 0\n\n\twhile sec_index < set2.size && first_index < set1.size do \n\t\tif set1[first_index].to_i > set2[sec_index].to_i\n\t\t\tsec_index += 1\n\t\telsif set1[first_index].to_i == set2[sec_index].to_i\n\t\t\tresult << set1[first_index]\n\t\t\tfirst_index += 1\n\t\telsif set1[first_index].to_i < set2[sec_index].to_i\n\t\t\tfirst_index += 1\n\t\tend\n\tend\n\treturn result\nend",
"def merge_query_objects(*query_objects)\n merged_query = {}.with_indifferent_access\n query_objects.compact.each do |query|\n query.each_pair do |facet_name, opts|\n if merged_query[facet_name].nil?\n merged_query[facet_name] = opts\n else\n opts.each_pair do |operator, values|\n values.each do |value|\n merged_query[facet_name][operator] << value unless merged_query[facet_name][operator].include?(value)\n end\n end\n end\n end\n end\n merged_query\n end",
"def intersection(head1, head2)\n length1 = 0\n length2 = 0\n\n current1 = head1\n current2 = head2\n# as oppose to calculate both simultanously just break it out into a method\n# that does each of them individually.\n while current1 != nil || current2 != nil\n length1 += 1 unless current1.nil?\n length2 += 1 unless current2.nil?\n\n if current1 && current1.next == nil\n last_current1 = current1\n end\n\n if current2 && current2.next == nil\n last_current2 = current2\n end\n\n current1 = current1.next unless current1.nil?\n current2 = current2.next unless current2.nil?\n end\n\n if last_current1.object_id != last_current2.object_id\n return 'The list do not intersect'\n end\n\n current1 == head1\n current2 == head2\n\n longest_list = length1 > length2 ? head1 : head2\n shortest_list = length1 < length2 ? head1 : head2\n\n diff = (length1 - length2).abs\n current_long = longest_list\n\n while diff != 0\n current_long = current_long.next\n diff -= 1\n end\n\n current_short = shortest_list\n\n while current_short != nil\n if current_short.object_id == current_long.object_id\n return current_short\n end\n\n current_short = current_short.next\n current_long = current_long.next\n end\nend",
"def intersect(array1, array2)\n hash_table = {}\n mergedArray = []\n\n array1.each do |a1|\n hash_table[a1] = true\n end\n\n array2.each do |a2|\n mergedArray << a2 if hash_table[a2]\n end\n\n return mergedArray\nend",
"def findTheIntersections\n intersection = [] #Numeros que A y B comparten\n differenceB = [] #Numeros que B tiene y no A\n differenceA =[] #Numero que A tiene y no B\n puts \"Sus intersecciones son: \"\n #Aqui se saca la interseccion \n for i in [email protected]\n if @A.include?(@B[i]) == true\n intersection.push(@B[i])\n i +=1 \n end\n end\n #Aqui solo se buscan los numeros diferentes entre A y B\n for u in [email protected]\n if @B.include?(@A[u]) == false\n differenceA.push(@A[u])\n u +=1 \n end\n end\n #Aqui solo se buscan los numeros diferentes entre B y A\n for i in [email protected]\n if @A.include?(@B[i]) == false\n differenceB.push(@B[i])\n i +=1 \n end\n end\n #Aqui se hace la union\n union = intersection + differenceA +differenceB\n #Por ultimo se imprime\n puts \"A ⋂ B = #{intersection}\"\n puts \"A ⋃ B = #{union.sort}\"\n puts \"A — B = #{differenceA}\" \n puts \"B — A = #{differenceB}\" \n end",
"def intersection(array_1, array_2)\n puts \"NOT IMPLEMENTED\"\n return []\nend",
"def includes(*args)\n fresh.tap do |criteria|\n criteria.includes_values = (includes_values || []) + args\n end\n end",
"def merge(other)\n other = other.criteria\n\n fresh.tap do |criteria|\n [\n :profile_value, :failsafe_value, :terminate_after_value, :timeout_value, :offset_value,\n :limit_value, :scroll_args, :source_value, :preference_value, :search_type_value,\n :routing_value, :track_total_hits_value, :explain_value, :http_timeout_value\n ].each do |name|\n criteria.send(:\"#{name}=\", other.send(name)) unless other.send(name).nil?\n end\n\n [\n :sort_values, :includes_values, :preload_values, :eager_load_values, :must_values,\n :must_not_values, :filter_values, :post_must_values, :post_must_not_values,\n :post_filter_values\n ].each do |name|\n criteria.send(:\"#{name}=\", (criteria.send(name) || []) + other.send(name)) if other.send(name)\n end\n\n [:highlight_values, :suggest_values, :custom_value, :aggregation_values].each do |name|\n criteria.send(:\"#{name}=\", (criteria.send(name) || {}).merge(other.send(name))) if other.send(name)\n end\n end\n end",
"def merge_resultsets(result1, result2); end",
"def merge_resultsets(result1, result2); end",
"def &(other)\n # transform self into a LinkedHashSet to remove duplicates and preserve order as defined by the Ruby Array intersection contract\n duped = Java::JavaUtil::LinkedHashSet.new(self)\n duped.retainAll(other)\n duped\n end",
"def merge(other)\n case other\n when Enumerable then other.each{ |item| push(item) }\n else push(other)\n end\n self\n end",
"def queries(with_orgs=true)\n condition_parts(with_orgs).reduce(:merge)\n end",
"def union(other)\n set_operation(other, :+,\n distinct: true,\n add_boundaries: true)\n end",
"def intersection\n\t\t\tarray = self.sort_elements\n\t\t\tarray.inject() do |common, element|\n\t\t\t\tvalue_first = comparison_value(common, :last)\n\t\t\t\tvalue_element = comparison_value(element, :first)\n\t\t\t\tcase value_first <=> value_element\n\t\t\t\twhen -1 then return nil\n\t\t\t\twhen 0 then value_first\n\t\t\t\telse\n\t\t\t\t\tif element.class == Range \n\t\t\t\t\t\tvalue_element..([value_first, comparison_value(element, :last)].min)\n\t\t\t\t\telse\n\t\t\t\t\t\tvalue_element\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def intersection(other)\n [first, other.begin].max..[last, other.end].min\n end",
"def __intersect__(object)\n object.__intersect_from_array__(self)\n end",
"def combine_filtered_ids(u_filtered_ids, b_filtered_ids, m_filtered_ids, d_filtered_ids, tenant_filter_ids)\n intersection = ->(operand1, operand2) { [operand1, operand2].compact.reduce(&:&) }\n union = ->(operand1, operand2, operand3 = nil) { [operand1, operand2, operand3].compact.reduce(&:|) }\n\n b_intersection_m = intersection.call(b_filtered_ids, m_filtered_ids)\n u_union_d_union_b_intersection_m = union.call(u_filtered_ids, d_filtered_ids, b_intersection_m)\n\n intersection.call(u_union_d_union_b_intersection_m, tenant_filter_ids)\n end",
"def intersect(nums1, nums2)\n nums1.sort!\n nums2.sort!\n\n pointer_1 = 0\n pointer_2 = 0\n\n intersection = []\n while pointer_1 < nums1.length && pointer_2 < nums2.length\n selected = nums1[pointer_1]\n while pointer_2 < nums2.length && nums2[pointer_2] < selected\n pointer_2 += 1\n end\n\n if pointer_2 >= nums2.length\n return intersection\n end\n\n count = 0\n while nums1[pointer_1] && nums2[pointer_2] && nums1[pointer_1] == nums2[pointer_2]\n count += 1\n pointer_1 += 1\n pointer_2 += 1\n end\n\n intersection += [selected] * count\n\n while nums1[pointer_1] && nums1[pointer_1] == selected\n pointer_1 += 1\n end\n end\n\n intersection\nend",
"def concat(other)\n other.each do |obj|\n add obj\n end\n self\n end",
"def intersection(another_transmembrane_domain_defintion)\n res = (@start..@stop).to_a & (another_transmembrane_domain_defintion.start..another_transmembrane_domain_defintion.stop).to_a\n res.empty? ? nil : (res.first..res.last)\n end",
"def intersection(list1, list2)\n current1 = list1.head\n current2 = list2.head\n visited = Set.new\n until current1.nil?\n visited << current1.hash\n current1 = current1.next\n end\n until current2.nil?\n return current2 if visited.include? current2.hash\n current2 = current2.next\n end\n nil\nend",
"def intersect(tenant_id,entity_type_id_1,entity_id_1,entity_type_id_2,strict_number)\n @instance.intersect(tenant_id,entity_type_id_1,entity_id_1,entity_type_id_2,strict_number)\n end",
"def intersect!(other)\n redis.sinterstore key, key, other.key\n ensure\n notify_changed\n end",
"def intersect?(other_set)\n requires_set(other_set, __method__)\n intersection(other_set).any?\n end",
"def union(other)\n set = MyHashSet.new\n (to_a + other.to_a).uniq.each { |el| set.insert(el) }\n set\n end",
"def intersect(dataset, opts=OPTS)\n raise(InvalidOperation, \"INTERSECT not supported\") unless supports_intersect_except?\n raise(InvalidOperation, \"INTERSECT ALL not supported\") if opts[:all] && !supports_intersect_except_all?\n compound_clone(:intersect, dataset, opts)\n end",
"def update!(**args)\n @intersection = args[:intersection] if args.key?(:intersection)\n end",
"def get_intersection\n end",
"def add_query_elements(query_elements)\n @query_elements.merge! query_elements\n self\n end",
"def intersection(b)\n @pages.delete_if { |k, v| not b.pages.include?(k) }\n self\n end",
"def intersection(nums1, nums2)\n hsh = {}\n result = []\n\n nums1.each do |num|\n hsh[num] = true\n end\n\n nums2.each do |num|\n if hsh[num]\n result.push(num) \n hsh[num] = false\n end\n end\n\n result\nend",
"def intersect(dataset, all = false)\n clone(:intersect => dataset, :intersect_all => all)\n end",
"def union(other_set)\n new_set = @set\n # Create an array with elements that are members of either set\n other_set.set.each do |element|\n new_set.push(element)\n end\n Set.new(new_set)\n end",
"def union(other, items = ::Set.new)\n LazyList.new do\n next other._uniq(items) if empty?\n next tail.union(other, items) if items.include?(head)\n Cons.new(head, tail.union(other, items.add(head)))\n end\n end",
"def intersect(other)\n @bits & bits_from_object(other)\n end",
"def +(other_list)\n union_list = self.class.copy_list(self)\n other_list.list.each do |item, int_value|\n union_list.list[item] = int_value\n end\n\n return union_list\n end",
"def intersection(fa)\n perform_set_operation(:intersection, fa)\n end",
"def merge(other); end",
"def merge(arr1, arr2)\n to_add = arr2.select{|element| arr1.include?(element) == false}\n arr1 + to_add\nend",
"def joined_results\n if conflict?\n if @conflict_handler\n @conflict_handler[results]\n else\n results\n end\n else\n first, rest = results.first, results[1..-1]\n rest.reduce(first) { |rs, r| rs.combine(r) }.apply(@join_function).result\n end\n end",
"def intersection(nums1, nums2)\n unique = {}\n res = []\n nums1.each do |num|\n if !(unique[num])\n unique[num] = true\n end\n end\n \n nums2.each do |num|\n if unique[num] && !(res.include?(num))\n res.push(num)\n end\n end\n \n res\n end",
"def cache_intersection(nums1, nums2)\n array = []\n outer_cache = {}\n inner_cache = {}\n nums1.each do |outer|\n next if outer_cache[outer]\n outer_cache[outer] = true\n nums2.each do |inner| \n next if inner_cache[inner]\n if outer == inner \n array << inner\n inner_cache[inner] = true\n end\n end\n end\n array\nend",
"def intersection1(arr1, arr2)\n arr1.uniq.select { |el| arr2.include?(el) }\nend",
"def containing(query)\n @query[:Query] << query\n self\n end",
"def fully_includes?(other)\n overlaps?(other) && other == intersection(other)\n end",
"def bt_intersect(*args)\n where(arel_bt_intersect(*bt_temporal(*args)))\n end",
"def merge(other)\n if include?(other.begin) || other.include?(self.begin)\n cmp = self.begin <=> other.begin\n if cmp < 0\n min = self.begin\n excl_begin = exclude_begin?\n elsif cmp > 0\n min = other.begin\n excl_begin = other.exclude_begin?\n else\n min = self.begin\n excl_begin = exclude_begin? && other.exclude_begin?\n end\n\n cmp = self.end <=> other.end\n if cmp > 0\n max = self.end\n excl_end = self.exclude_end?\n elsif cmp < 0\n max = other.end\n excl_end = other.exclude_end?\n else\n max = self.end\n excl_end = exclude_end && other.exclude_end?\n end\n\n MinMaxRange.create(excl_begin ? GtRange.new(min) : GtEqRange.new(min), excl_end ? LtRange.new(max) : LtEqRange.new(max))\n elsif exclude_end? && !other.exclude_begin? && self.end == other.begin\n # Adjacent, self before other\n from_to(self, other)\n elsif other.exclude_end? && !exclude_begin? && other.end == self.begin\n # Adjacent, other before self\n from_to(other, self)\n elsif !exclude_end? && !other.exclude_begin? && self.end.next(:patch) == other.begin\n # Adjacent, self before other\n from_to(self, other)\n elsif !other.exclude_end? && !exclude_begin? && other.end.next(:patch) == self.begin\n # Adjacent, other before self\n from_to(other, self)\n else\n # No overlap\n nil\n end\n end",
"def fast_intersection(array_one, array_two)\nend",
"def concat(other)\n @requests.concat(other.get_requests())\n self\n end",
"def merge(intervals_a, intervals_b)\n\tmerged = []\n\n\ti, j, start_point, end_point = 0,0,0,1\n\n\twhile i < intervals_a.length and j < intervals_b.length\n\n\t\t# check if intervals overlap and intervals_a[i]'s start time lies within the other intervals_b[j]\n\t\ta_overlaps_b = intervals_a[i][start_point] >= intervals_b[j][start_point] && intervals_a[i][start_point] <= intervals_b[j][end_point]\n\n\t\t# check if intervals overlap and intervals_b[j]'s start time lies within the other intervals_a[i]\n\t\tb_overlaps_a = intervals_b[j][start_point] >= intervals_a[i][start_point] && intervals_b[j][start_point] <= intervals_a[i][end_point]\n\n\t\t# store the the intersection part\n\n\t\tif a_overlaps_b || b_overlaps_a\n\t\t\tnew_start = [intervals_a[i][start_point], intervals_b[j][start_point]].max\n\t\t\tnew_end = [intervals_a[i][end_point], intervals_b[j][end_point]].min\n\t\t\tmerged.append([new_start, new_end])\n\t\tend\n\n\t\t# move next from the interval which is finishing first\n\n\t\tif intervals_a[i][end_point] < intervals_b[j][end_point]\n\t\t\ti += 1\n\t\telse\n\t\t\tj += 1\n\t\tend\n\n\tend\n\n\treturn merged\n\nend",
"def intersect_with(recurse, transform1, entities1, transform2, hidden, entities2)\n end",
"def intersection_of_arrays(nums1, nums2)\n # nums1 = nums1.sort!\n # nums2 = nums2.sort!\n nums1 & nums2\nend",
"def intersection(array1, array2)\n return [] if array1.nil? || array2.nil? || array1 == [] || array2 == []\n return [] if array1 == [] && array2 == []\n return array1 if array1 == array2\n\n intersection = []\n array1.each do |i|\n array2.each do |j|\n intersection << i if i == j\n end\n end\n\n return intersection\nend",
"def intersection(list1, list2)\n seen = {}\n\n list1_current = list1.head.next\n list2_current = list2.head.next\n\n while list1_current.next.value || list2_current.next.value\n return list1_current if seen[list1_current]\n return list2_current if seen[list2_current]\n\n seen[list1_current] = true\n seen[list2_current] = true\n\n list1_current = list1_current.next\n list2_current = list2_current.next\n end\n\n false\nend",
"def intersection3(arr1, arr2)\n intersection = []\n set_1 = arr1.to_set\n arr2.each do |el|\n intersection << el if set_1[el]\n end\n\n intersection\nend",
"def merge_event_lists(list1, list2)\n recalc_times(0, list1)\n recalc_times(0, list2)\n list = list1 + list2\n recalc_delta_from_times(0, list)\n return list\n end",
"def join(other)\n new(entries.merge(other.entries) { |_name, old, new| old + new })\n end"
] | [
"0.65731716",
"0.64676946",
"0.6419824",
"0.635614",
"0.6240802",
"0.6103736",
"0.6079205",
"0.60788554",
"0.5973304",
"0.5971937",
"0.596858",
"0.59236866",
"0.59108394",
"0.57837355",
"0.574916",
"0.56583667",
"0.56556636",
"0.5654523",
"0.5567013",
"0.55310977",
"0.5529876",
"0.5514729",
"0.55132633",
"0.5494999",
"0.5468639",
"0.5449673",
"0.5441706",
"0.5382926",
"0.53580207",
"0.5341908",
"0.5339825",
"0.53293616",
"0.5270478",
"0.5262225",
"0.52516407",
"0.5241908",
"0.5239168",
"0.5229755",
"0.5224737",
"0.5204327",
"0.5174761",
"0.51606786",
"0.5158734",
"0.51319456",
"0.5126435",
"0.51129496",
"0.51051635",
"0.5102851",
"0.5099519",
"0.5095795",
"0.50946194",
"0.50745344",
"0.5071035",
"0.50658715",
"0.50623727",
"0.5061392",
"0.50454676",
"0.5041722",
"0.5039081",
"0.5034675",
"0.5028372",
"0.5021782",
"0.50195205",
"0.5017992",
"0.50179285",
"0.5013166",
"0.5008945",
"0.50028956",
"0.50013685",
"0.49860272",
"0.49546725",
"0.49525264",
"0.4945883",
"0.49417",
"0.49387062",
"0.4936678",
"0.49344292",
"0.49292067",
"0.49175206",
"0.49120447",
"0.49096358",
"0.49086314",
"0.48946497",
"0.48918054",
"0.48793912",
"0.48765045",
"0.48473024",
"0.4830984",
"0.4824737",
"0.4819049",
"0.48049712",
"0.480056",
"0.47881272",
"0.47873855",
"0.47862768",
"0.47845015",
"0.4784494",
"0.4780842",
"0.47801605"
] | 0.7463428 | 0 |
Returns the CSS for the media query list. | def to_css
queries.map {|q| q.to_css}.join(', ')
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def css_render\n css_list.join(\"\\n\")\n end",
"def css_styles\n @css_styles ||= []\n end",
"def media_colors\n return @media_colors\n end",
"def media_styles_croppable_list\n list = Ubiquo::Config.context(:ubiquo_media).get(:media_styles_list)\n # The main styles are not croppable as they belong to the core\n Ubiquo::Config.context(:ubiquo_media).get(:media_core_styles).each do |s|\n list.delete(s)\n end\n # Filter the formats that are not strings like \"300x200#\"\n list.delete_if{|k,v| !v.respond_to?( :match )}\n list\n end",
"def media_quality_list\n return @media_quality_list\n end",
"def find_css\n @dom.css(STYLE_ELEMENT_QUERY).map { |element| read_stylesheet(element) }.compact\n end",
"def list_css_class\n \"#{model_type}-list\"\n end",
"def css_config\n {\n css: {\n properties: %w(content counter-increment counter-reset counter-set list-style-type)\n }\n }\n end",
"def css css_selector\n @scene.get_root.lookup_all(css_selector).map {|e| e}\n end",
"def style\n return \"\" if self.class.styles_pool.blank?\n\n common_style = self.class.styles_pool[:_common] || []\n common_style_without_fill_window = common_style - [FILL_WINDOW_CSS]\n if screen = params.try(:[], :screen)\n screen_style = self.class.styles_pool[screen] || []\n (screen_style.blank? ? common_style : (common_style_without_fill_window + screen_style)).uniq.join(\" \")\n else\n common_style.join(\" \")\n end\n end",
"def css_styles\n end",
"def css_class(name_prefix='')\n\t\t\"#{name_prefix}list\"\n\tend",
"def css(query)\n\t\treturn is_valid ? @doc.css(query) : nil\n\tend",
"def css\n Sass::Tree::Visitors::ToCss.new.visit(self)\n end",
"def render_list_css\n\t\tresponse = Rack::Response.new\n\t\tFile.open(\"list.css\", \"rb\") { |css| response.write(css.read) }\n\t\tresponse.finish\n\tend",
"def render_list_css\n\t\tresponse = Rack::Response.new\n\t\tFile.open(\"list.css\", \"rb\") { |css| response.write(css.read) }\n\t\tresponse.finish\n\tend",
"def printCSS\r\n css=\"<style type=\\\"text/css\\\">\\n\" \r\n @concreteInterfaceIds.each do\r\n |concrete_interface|\r\n concrete_interface = SWUI::ConcreteInterface.find_by.interface_name(concrete_interface).execute.first.concrete_interface_code.first\r\n css << concrete_interface\r\n css << \"\\n\"\r\n end\r\n @ajaxcontrolIds.each do\r\n |ajaxcontrolId|\r\n ajaxcontrol = SWUI::RichControl.find_by.concrete_widget_name(ajaxcontrolId).execute.first\r\n cssCode = ajaxcontrol.cssCode.first\r\n css << \"#{cssCode}\\n\"\r\n end\r\n css << \"</style>\\n\"\r\n return css\r\n end",
"def stylesheets\n @parts.values.map(&:stylesheet).compact\n end",
"def get_css_classes(output, post)\n # here we contruct the css classes to add to the media\n # we don't add zurb foundation flex-video tags for mp3 embeds\n css_classes = \"flex-video widescreen\" unless post.url[-4..-1] == \".mp3\"\n css_classes = css_classes + \" youtube\" if output.include? \"youtube.com\"\n css_classes = css_classes + \" vimeo\" if output.include? \"vimeo.com\"\n # Reset classes for images\n css_classes = \"image\" if post.url[-4..-1] == \".jpg\" or post.url[-4..-1] == \".gif\" or post.url[-4..-1] == \".png\" or post.url[-5..-1] == \".jpeg\"\n return css_classes\n end",
"def css_tags\n css.map do |url|\n \"<link href=\\\"#{url}\\\" media=\\\"all\\\" rel=\\\"stylesheet\\\" type=\\\"text/css\\\" />\"\n end.join(\"\\n\")\n end",
"def styles\n mentos(:get_all_styles)\n end",
"def fb_css\n '<style>\n .lists th {\n text-align: left;\n padding: 5px 10px;\n background: #6d84b4;\n }\n\n .lists .spacer {\n background: none;\n border: none;\n padding: 0px;\n margin: 0px;\n width: 10px; \n }\n\n .lists th h4 { float: left; color: white; }\n .lists th a { float: right; font-weight: normal; color: #d9dfea; }\n .lists th a:hover { color: white; }\n\n .lists td {\n margin:0px 10px;\n padding:0px;\n vertical-align:top;\n }\n\n .lists .list {\n background:white none repeat scroll 0%;\n border-color:-moz-use-text-color #BBBBBB;\n border-style:none solid;\n border-width:medium 1px;\n }\n .lists .list .list_item { border-top:1px solid #E5E5E5; padding: 10px; }\n .lists .list .list_item.first { border-top: none; }\n\n .lists .see_all {\n background:white none repeat scroll 0%;\n border-color:-moz-use-text-color #BBBBBB rgb(187, 187, 187);\n border-style:none solid solid;\n border-width:medium 1px 1px;\n text-align:left;\n }\n\n .lists .see_all div { border-top:1px solid #E5E5E5; padding:5px 10px; }\n \n </style>' \n end",
"def media_types\n return @media_types\n end",
"def css\n @css ||= assemble_css\n end",
"def gridmaxwidths ()\n # write a media query for each breakpoint\n $g = 0\n items = MEASURES\n $LEN = items.length\n $buffer = \"\"\n\n until $g == $LEN\n if $g == 0\n $NAME = 0\n $NAMETXT = \"default\"\n else\n $NAME = \"$bp-\" + items[$g]['NAME']\n $NAMETXT = $NAME\n end\n $FROM = items[$g]['FROM']\n $MAXW = items[$g]['MAXW']\n $buffer += \"\n /* #$NAMETXT breakpoint (#$FROM) */\n @media (min-width: #$NAME){\n .wrapbox {\n max-width: #$MAXW; \n }\n }\n \"\n\n $g += 1\n end\n\n return $buffer\nend",
"def css_class_names\n @css_class_names ||= []\n end",
"def render_style(text, mediatype=\"all\")\n [\"<style type='text/css' media='#{mediatype}' >\",\n text,\n \"</style>\\n\"].join(\"\\n\") \n end",
"def inline_styles\n parser.css(\"style\").to_a\n end",
"def to_s\n '#<Twilio.Media.V1.MediaProcessorList>'\n end",
"def to_css\n css = ''\n css << resolved_modifier\n css << ' ' unless resolved_modifier.empty?\n css << resolved_type\n css << ' and ' unless resolved_type.empty? || expressions.empty?\n css << expressions.map do |e|\n # It's possible for there to be script nodes in Expressions even when\n # we're converting to CSS in the case where we parsed the document as\n # CSS originally (as in css_test.rb).\n e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.to_sass : c.to_s}.join\n end.join(' and ')\n css\n end",
"def reader_css_paths\n @css ||= []\n @css.uniq\n end",
"def media_list\n @redis.hkeys(\"contact_media:#{self.id}\") - ['pagerduty']\n end",
"def css\n options.fetch :css, CSS_SELECTOR\n end",
"def gen_css(levels, minmax)\n # Header\n css = CSS_HEADER\n\n # Disable everything to start with \n levels.times{|l|\n css += \"\\n.#{class_name(l)}{ display: none; }\"\n }\n \n # Compute the various widths' display rules\n step = (minmax[MAX] - minmax[MIN]) / levels\n levels.times{|x|\n css += \"\\n@media (min-width: #{ x*step + minmax[MIN] }){\"\n (x+1).times{|l|\n css += \"\\n.#{class_name(l)}{ display: inline; }\"\n }\n css += \"\\n}\"\n }\n\n # Return with the end <script>\n return css + CSS_FOOTER\nend",
"def media_colors=(value)\n @media_colors = value\n end",
"def extract_css\n @dom.css(STYLE_ELEMENT_QUERY).map { |element|\n stylesheet = read_stylesheet(element)\n element.remove if stylesheet\n stylesheet\n }.compact\n end",
"def css_class\n @css_class ||= [\"project\", status.gsub(' ','-').downcase, (hideable? ? \"hideable\" : nil)].compact.join(\" \")\n end",
"def media_sizes\n return @media_sizes\n end",
"def css_class\n result = [self.project.try(:css_class), self.try(:format).try(:css_class)].join(' ')\n result = 'other' unless CSS_CLASSES.include?(result)\n result += ' invisible' unless self.is_visible\n result\n end",
"def css; end",
"def css; end",
"def css; end",
"def style\n `$q(this.__native__.style.cssText)`\n end",
"def rules_and_comments_to_css(items, style, args)\n r = ''\n if items.size > 0\n item_strs = items.map do |item|\n item.to_css(style,\n :context => :ruleset,\n :depth => (args.depth + 1))\n end\n r << style.subrule_before\n r << item_strs.join('')\n end\n\n # Remove trailing \\n's\n r.gsub! /\\n+$/, \"\\n\"\n r\n end",
"def embed_code_css\n if video? || image? || interactive_map?\n responsive_embed_code_css\n elsif audio?\n audio_embed_code_css\n end\n end",
"def to_css\n styles = []\n %w( chessboard mini-chessboard ).each do |board_class|\n if light_square_color\n styles << \"\n .#{board_class} .square.light {\n background: #{light_square_color} !important;\n }\n .#{board_class} .square .square-label.dark {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-white coords.ranks coord:nth-child(2n + 1) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-white coords.files coord:nth-child(2n + 1) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-black coords.ranks coord:nth-child(2n) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-black coords.files coord:nth-child(2n) {\n color: #{light_square_color} !important;\n }\n \"\n end\n if dark_square_color\n styles << \"\n .#{board_class} .square.dark {\n background: #{dark_square_color} !important;\n }\n .#{board_class} .square .square-label.light {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-white coords.ranks coord:nth-child(2n) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-white coords.files coord:nth-child(2n) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-black coords.ranks coord:nth-child(2n + 1) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-black coords.files coord:nth-child(2n + 1) {\n color: #{dark_square_color} !important;\n }\n \"\n end\n if light_square_color || dark_square_color\n board_svg = %(\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n <svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:x=\"http://www.w3.org/1999/xlink\"\n viewBox=\"0 0 8 8\" shape-rendering=\"crispEdges\">\n <g id=\"a\">\n <g id=\"b\">\n <g id=\"c\">\n <g id=\"d\">\n <rect width=\"1\" height=\"1\" fill=\"#{light_square_color || \"#F3E4CF\"}\" id=\"e\"/>\n <use x=\"1\" y=\"1\" href=\"#e\" x:href=\"#e\"/>\n <rect y=\"1\" width=\"1\" height=\"1\" fill=\"#{dark_square_color || \"#CEB3A2\"}\" id=\"f\"/>\n <use x=\"1\" y=\"-1\" href=\"#f\" x:href=\"#f\"/>\n </g>\n <use x=\"2\" href=\"#d\" x:href=\"#d\"/>\n </g>\n <use x=\"4\" href=\"#c\" x:href=\"#c\"/>\n </g>\n <use y=\"2\" href=\"#b\" x:href=\"#b\"/>\n </g>\n <use y=\"4\" href=\"#a\" x:href=\"#a\"/>\n </svg>\n ).strip\n base64_board_svg = Base64.encode64(board_svg).gsub(/\\n/, '').strip\n styles << \"\n cg-board {\n background-image: url('data:image/svg+xml;base64,#{base64_board_svg}');\n }\n \"\n end\n if selected_square_color\n styles << \"\n .#{board_class} .square[data-selected] {\n background: #{selected_square_color} !important;\n }\n cg-board square.selected {\n background: #{selected_square_color} !important;\n }\n \"\n end\n if opponent_from_square_color\n styles << \"\n .#{board_class} .square[data-from] {\n background: #{opponent_from_square_color} !important;\n }\n .#{board_class} .square.move-from {\n background: #{opponent_from_square_color} !important;\n }\n cg-board square.last-move.move-from {\n background-color: #{opponent_from_square_color} !important;\n }\n \"\n end\n if opponent_to_square_color\n styles << \"\n .#{board_class} .square[data-to] {\n background: #{opponent_to_square_color} !important;\n }\n .#{board_class} .square.move-to {\n background: #{opponent_to_square_color} !important;\n }\n cg-board square.last-move.move-to {\n background-color: #{opponent_to_square_color} !important;\n }\n \"\n end\n end\n return unless styles.length > 0\n styles.join(\"\\n\").html_safe\n end",
"def answer_css\n %(#answer-#{@answer.id})\n end",
"def admin_edit_layout_style_list\n %w( [email protected] )\n end",
"def css_options\n css_keys = [:compress, :optimization, :silent, :color]\n Hash[less_options.to_enum.to_a.select{|k, _| css_keys.include? k}]\n end",
"def list_styles(**opt)\n # Overridden by the subclass if configured for search analysis.\n end",
"def to_s\n '#<Twilio.Intelligence.V2.MediaList>'\n end",
"def list_entry_css_classes(list_entry)\n list_classes = []\n list_classes << (list_entry.children? ? 'is-list' : '')\n list_classes << (list_entry.ancestors? ? '' : 'top-level-list')\n\n list_classes\n end",
"def to_css\n css = ''\n css << resolved_modifier\n css << ' ' unless resolved_modifier.empty?\n css << resolved_type\n css << ' and ' unless resolved_type.empty? || expressions.empty?\n css << expressions.map {|e| e.to_css}.join(' and ')\n css\n end",
"def fullscreen_sizes\n \"(min-width: #{fullscreen_max_width}px) #{fullscreen_max_width}px, 100vw\"\n end",
"def stylesheets\n sheets = []\n sheets << settings.stylesheets.keys if settings.respond_to?('stylesheets')\n sheets << @styles if @styles\n sheets.flatten.uniq.map do |css|\n \"<link href='#{path_to_styles css }' rel='stylesheet' type='text/css'>\"\n end.join\n end",
"def build_imagecss\n return unless options.Build_Image_Width_Css\n\n puts_cyan \"Middlemac is creating `#{options.File_Image_Width_Css}`.\"\n\n out_array = []\n\n Dir.glob(\"#{app.source}/Resources/**/*.{jpg,png,gif}\").each do |fileName|\n # fileName contains complete path relative to this script.\n # Get just the name and extension.\n base_name = File.basename(fileName)\n\n # width\n if File.basename(base_name, '.*').end_with?('@2x')\n width = (FastImage.size(fileName)[0] / 2).to_i.to_s\n else\n width = FastImage.size(fileName)[0].to_s;\n end\n\n # proposed css\n out_array << \"img[src$='#{base_name}'] { max-width: #{width}px; }\"\n end\n\n File.open(options.File_Image_Width_Css, 'w') { |f| out_array.each { |line| f.puts(line) } }\n\n end",
"def responsive_embed_code_css\n <<~END\n #fulcrum-embed-outer-#{id} {\n width:auto;\n page-break-inside:avoid;\n -webkit-column-break-inside:avoid;\n break-inside:avoid;\n max-width:#{embed_width}px;\n margin:auto;\n background-color:#000;\n }\n #fulcrum-embed-inner-#{id} {\n overflow:hidden;\n padding-bottom:#{padding_bottom}%;\n position:relative; height:0;\n }\n iframe#fulcrum-embed-iframe-#{id} {\n overflow:hidden;\n border-width:0;\n left:0; top:0;\n width:100%;\n height:100%;\n position:absolute;\n }\n END\n end",
"def media_quality_list=(value)\n @media_quality_list = value\n end",
"def css(page_css) \n page_css.split(' ').each do |item|\n content_for(:css) do\n \"<link href=\\\"/stylesheets/#{page_css}.css\\\" rel='stylesheet' type='text/css'/>\\n\" \n end \n end\n end",
"def css_classes\n css_classes = []\n css_classes << 'not-read' unless read\n css_classes << 'important' if important\n css_classes.join(' ')\n end",
"def stylesheets\n styles.zip(style_files).map do |name, path|\n base = File.basename(path, '.css')\n raise \"style not found: #{style.inspect}\" if path.nil?\n {\n name: name,\n path: path,\n base: File.basename(path, '.css'),\n media: base =~ /(print|screen)$/ ? $1 : 'all'\n }\n end\n end",
"def css\n css_files = []\n @assets.each do |type, path|\n case type\n when :folder\n # Don't import any css/scss files that start with an underscore, so scss partials\n # aren't imported by default:\n # http://sass-lang.com/guide\n css_files += Dir[\"#{path}/**/[^_]*.{css,scss}\"].sort.map do |folder|\n '/assets' + folder[path.size..-1].gsub(/[.]scss$/, '')\n end\n when :css_file\n css_files << path\n end\n end\n\n css_files.uniq\n end",
"def css_class\n end",
"def styles\n return @metadata[:styles]\n end",
"def media_list\n source_media.sort{|x,y| x.medium <=> y.medium }.map{ |x| x.medium }.join(', ')\n end",
"def rmq_style_applied\n on_styled\n end",
"def stylist\n\n end",
"def test_initialize_with_css_code\n css_parser = Hatemile::Util::Css::Rcp::RCPParser.new(CSS_CODE)\n rules = css_parser.get_rules(['color'])\n\n assert_equal(4, rules.length)\n end",
"def breakpoints\n @breakpoints ||= []\n end",
"def stylesheets\n sort(css.clone.concat(sass_without_partials), config['order_css'] || [])\n end",
"def styles; end",
"def styles; end",
"def styles; end",
"def styles\n @styles ||= DEFAULT_STYLES\n end",
"def css_class\n @css_class ||= \"project #{status.gsub(' ','-').downcase}\"\n end",
"def people_list_style\n list_styles = people_list_styles_for_select.map(&:last)\n if params[:people_list_style].blank?\n list_style = list_styles.include?(session[:people_list_style]) ? session[:people_list_style] : RedminePeople.default_list_style\n else\n list_style = list_styles.include?(params[:people_list_style]) ? params[:people_list_style] : RedminePeople.default_list_style\n end\n session[:people_list_style] = list_style\n end",
"def collage_canvas_styles\n styles = []\n styles << 'height: 0px'\n styles << \"padding-bottom: #{collage_height_ratio}%\"\n styles.join('; ')\n end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def css_for(hash)\n unless hash.blank?\n css = []\n\n hash.each do |selector, attributes|\n unless attributes.blank?\n guts = []\n attributes.each do |key, val|\n guts << \"#{ key } : #{ val };\"\n end\n unless guts.blank?\n css << \"#{ selector } { #{ guts.join(' ') } }\"\n end\n end\n end\n\n unless css.empty?\n css.join(\"\\n\")\n end\n end\n end",
"def css_classes\n s = \"meeting status-#{status}\"\n s << ' created-by-me' if User.current.logged? && author_id == User.current.id\n s\n end",
"def css_code\n '<style type=\"text/css\">' <<\n asset('webconsole.css') <<\n '</style>'\n end",
"def mobiles\n @mobiles || []\n end",
"def mcl\n build_settings_array RubyRedtail::Query.run(\"settings/mcl\", @api_hash, \"GET\")\n end",
"def render_css\n @menu ? \"#{@menu.css}\\n #{@selected ? @selected.css : ''}\\n\" : ''\nend",
"def make_css\n template = ERB.new TEMPLATE\n result = template.result binding\n (0..3).each { result.gsub!(/\\n;\\n/m, \";\\n\") }\n @result = result.gsub /^$\\n/, ''\n end",
"def get_calculated_style( query, style )\n #begin assemble javascript\n script = \"return jQuery('\"\n \n #selector query\n script << \"#{query}\"\n script << \"').css('\"\n \n #css styles to verify\n script << \"#{style}\"\n script << \"');\"\n \n begin\n return @wd.execute_script(\"#{script}\")\n rescue Selenium::WebDriver::Error::JavascriptError\n return \"Unable to obtain\"\n end\n end",
"def build_css(style_hash)\n q = ''\n q << style_hash.collect { |k, v|\n if not v.empty?\n q2 = ( k =~ /\\./ ? ( k[-1..-1] == '.' ? \"#{k[0..-2]}\" : \"#{k}\" ) : \"##{k}\" )\n q2 << ' {' << v.collect{| k2, v2 | \" #{k2}: #{v2}\" }.join( ';' ) << ' }'\n q2\n end\n }.join(\"\\n\")\n return q\n end",
"def css_for_doc(doc)\n css_urls_in_doc(doc).map { |url| css_for_url(url) }.join(\"\\n\")\n end",
"def render_css\r\n @css\r\nend",
"def styles\n return if @styles.empty?\n @styles.uniq.sort\n end",
"def ruleset_rules\n @rulesets.collect do |r|\n [\"# Begin [#{r.name}]\",\n r.firewall_rules,\n \"# End [#{r.name}]\",\n \"\"]\n end\n end",
"def stylesheet\n @stylesheet ||= Dir.glob(root+'/**/parts.*css').first\n end",
"def stylesheets\n Dir[Dir.pwd + '/*.css'].map { |path| File.read(path) }\n end",
"def stylesheets\n Dir[Dir.pwd + '/*.css'].map { |path| File.read(path) }\n end",
"def to_css\n css = '('\n css << resolved_name\n css << ': ' << resolved_value unless resolved_value.empty?\n css << ')'\n css\n end",
"def auto_complete_css\n auto_complete_skip_style ? '' : AUTO_COMPLETE_CSS\n end"
] | [
"0.6412106",
"0.57231975",
"0.560444",
"0.55454755",
"0.54734623",
"0.5353245",
"0.5317996",
"0.5287653",
"0.52215517",
"0.5210243",
"0.52072406",
"0.5194655",
"0.51916623",
"0.5149517",
"0.5143761",
"0.5143761",
"0.511654",
"0.5111628",
"0.5094868",
"0.50911117",
"0.507322",
"0.50725853",
"0.50680333",
"0.5047445",
"0.49796656",
"0.4960241",
"0.49356443",
"0.49309286",
"0.49078494",
"0.48815364",
"0.48669183",
"0.48545468",
"0.48513865",
"0.4828863",
"0.48233366",
"0.48114818",
"0.48068476",
"0.48066616",
"0.47957414",
"0.47916555",
"0.47916555",
"0.47916555",
"0.4789778",
"0.47676513",
"0.47670907",
"0.47470647",
"0.47279024",
"0.47196162",
"0.4718606",
"0.4698523",
"0.46809617",
"0.46716678",
"0.46483758",
"0.46449122",
"0.4642352",
"0.46339333",
"0.46135062",
"0.46093115",
"0.46064225",
"0.45639387",
"0.45632246",
"0.45618933",
"0.4540707",
"0.4539232",
"0.45281014",
"0.4525951",
"0.44992787",
"0.44822097",
"0.44773942",
"0.44714028",
"0.44611675",
"0.44611675",
"0.44611675",
"0.44574022",
"0.44522417",
"0.44407454",
"0.44349512",
"0.44248456",
"0.44248456",
"0.44248456",
"0.44248456",
"0.4423352",
"0.4422684",
"0.44154233",
"0.44126752",
"0.44080597",
"0.44010994",
"0.4396863",
"0.43966204",
"0.4393319",
"0.4378755",
"0.43745095",
"0.43738014",
"0.4369136",
"0.43678147",
"0.43659994",
"0.43659994",
"0.4365987",
"0.4361987"
] | 0.66031283 | 0 |
Returns a deep copy of this query list and all its children. | def deep_copy
QueryList.new(queries.map {|q| q.deep_copy})
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone\n q = super\n q.attrs = self.attrs.clone\n return q\n end",
"def deep_copy\n Query.new(\n modifier.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},\n type.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},\n expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}})\n end",
"def deep_copy\n Query.new(\n modifier.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},\n type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},\n expressions.map {|q| q.deep_copy})\n end",
"def shallow_clone\n cloned = self.clone\n cloned.remove_relations\n return cloned\n end",
"def deep_clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_clone\n Marshal::load(Marshal.dump(self))\n end",
"def deep_clone\n cloned = self.clone\n cloned.initialize_from_copy(self)\n cloned\n end",
"def deep_clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_clone\n Marshal::load(Marshal.dump(self))\n end",
"def clone\n copy = super\n copy.expressions = @expressions.map {|e| e.clone }\n copy\n end",
"def __deep_copy__\n self.class.new(aliases) do |copy|\n each do |entry|\n copy.push(entry.__deep_copy__)\n end\n end\n end",
"def deep_copy\n deep_transform_values(&method(:_deep_copy))\n end",
"def list\n @list.dup\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n obj = super\n elements = @elements.clone\n obj.instance_eval { @elements = elements }\n return obj\n end",
"def deep_copy\r\n Marshal.load(Marshal.dump(self))\r\n end",
"def __deep_copy__\n map { |value| value.__deep_copy__ }\n end",
"def clone\n copy = super\n copy.members = @members.map {|m| m.clone }\n copy\n end",
"def to_a\n @list.clone\n end",
"def deep_clone; Marshal::load(Marshal.dump(self)); end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def copy(query)\n queries << query\n end",
"def deep_clone; end",
"def all_children(scope = {})\n full_set(scope) - [self]\n end",
"def copy\n copy = self.clone\n copy.delete_all\n @collection.each do |obj|\n copy.add_param(obj.key,obj.value,obj.type)\n end\n return copy\n end",
"def select_all\n clone(:select => nil)\n end",
"def deep_clone\n bi = dup\n bi.save\n feature_selections.each { |fs| bi.feature_selections << fs.dup }\n bi\n end",
"def initialize_copy(original)\n super\n @query = @query.dup\n @cache = @cache.dup\n @orphans = @orphans.dup\n end",
"def deepcopy\n\t\tMarshal.load(Marshal.dump(self))\n\tend",
"def clone\n self.copy\n end",
"def clone\n self.copy\n end",
"def all(query = nil)\n if query.nil? || (query.kind_of?(Hash) && query.empty?)\n # TODO: after adding Enumerable methods to Model, try to return self here\n new_collection(self.query)\n else\n new_collection(scoped_query(query))\n end\n end",
"def clone\n @clone ||= super\n end",
"def __deep_copy__\n self.class.new(aliases, serializers, associations, aliased_associations) do |copy|\n each_pair do |key, value|\n copy.merge!(key => value.__deep_copy__)\n end\n end\n end",
"def copy\n\t\t\treturn self.dup\n\t\tend",
"def clone\n new_set = TreeSet.new\n # Create new nodes in the same order as self's\n if root\n root.root_traverse do |node|\n new_set << node.value\n end\n end\n new_set\n end",
"def all\n @all.dup\n end",
"def clone\n self\n end",
"def clone\n rContext = Context.new\n\n rContext.mergeWithContext(self)\n\n return rContext\n end",
"def clone\n return Marshal.load(Marshal.dump(self))\n end",
"def to_a\n items.deep_dup\n end",
"def clone_deep\n c = self.clone :include => collection_details\n c.updated_at = nil\n c.created_at = nil\n self.collection_details.each do |detail|\n c.send(detail).each do |d|\n d.created_at = nil\n d.updated_at = nil\n d.person_id = nil\n end\n end\n c\n end",
"def full_set(options = {})\n return [self] if new_record? or self[nested_set_right]-self[nested_set_left] == 1\n [self] + all_children(options)\n end",
"def descendants\n return [] if new_record?\n tree_search_class.where(tree_path_field => self._id).sort(self.class.tree_sort_order()).all\n end",
"def to_ary\n @descendants.dup\n end",
"def self_and_descendants_from_active_record\n [self]\n end",
"def items; @items.clone end",
"def select_all\n\t\treturn self.clone( :select => [] )\n\tend",
"def children\n dataset.nested.filter(self.class.qualified_parent_column => self.id)\n end",
"def clone\n copy = super\n transaction do\n copy.save!\n\n %w[\n registration_information support information_source advance_directive\n ].each do |assoc|\n copy.send(\"#{assoc}\\=\", send(assoc).clone) if send(assoc)\n end\n\n %w[\n patient_identifiers languages providers medications allergies conditions\n all_results immunizations encounters procedures medical_equipments social_history insurance_providers\n ].each do |assoc|\n send(assoc).each do |item|\n copy.send(assoc) << item.clone\n end\n end\n\n end\n copy\n end",
"def deep_copy\n answer = []\n %w[1 2 3 4 5 6].each do |elem|\n answer << elem.dup\n end\n answer\nend",
"def self_and_descendants_from_active_record\n [self]\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n copy = self.dup\n copy.create_command\n copy.serializer = self.serializer.deep_copy\n copy.deserializer = self.deserializer.deep_copy\n copy.commands = self.commands.dup\n copy.libraries = self.libraries.dup\n copy.bound_objects = self.bound_objects.dup\n copy\n end",
"def children\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND #{acts_as_nested_set_options[:parent_column]} = #{self.id}\", :order => acts_as_nested_set_options[:left_column])\n end",
"def clone\n self.class.new(@parent, @position)\n end",
"def all_children(options = {})\n conditions = \"(#{nested_set_left} > #{self[nested_set_left]}) and (#{nested_set_right} < #{self[nested_set_right]})\"\n if options[:exclude]\n transaction do\n # exclude some items and all their children\n options[:exclude] = [options[:exclude]] if !options[:exclude].is_a?(Array)\n # get objects for ids\n options[:exclude].collect! {|s| s.is_a?(nested_set_class) ? s : nested_set_class.find(s)}\n # get all subtrees and flatten the list\n exclude_list = options[:exclude].map{|e| e.full_set.map{|ee| ee.id}}.flatten.uniq\n conditions += \" AND id NOT IN (#{exclude_list.join(',')})\" unless exclude_list.empty?\n end\n end\n nested_set_class.find_with_nested_set_scope(:all, :conditions => conditions, :order => nested_set_left)\n end",
"def deep_clone\n if RUBY_PLATFORM == 'opal'\n JSON.parse(to_json)\n else\n Marshal.load(Marshal.dump(self))\n end\n end",
"def self_and_all_children\n [self] + all_children\n end",
"def recursive_clone\n\t\t\tnode_map = self.survey.node_maps.build(:survey => self.survey, :node => self.node)\n\t\t\tself.survey.node_maps.select { |i| i.parent == self && !i.marked_for_destruction? }.each { |child_node|\n\t\t\t\tchild_node.survey = self.survey # required due to voodoo - we want to use the same survey with the same object_id\n\t\t\t\tnode_map.children << child_node.recursive_clone\n\t\t\t}\n\t\t\tnode_map\n\t\tend",
"def children\n tree_search_class.where(tree_parent_id_field => self._id).sort(self.class.tree_sort_order()).all\n end",
"def siblings\n tree_search_class.where({\n :_id => { \"$ne\" => self._id },\n tree_parent_id_field => self[tree_parent_id_field]\n }).sort(self.class.tree_sort_order()).all\n end",
"def deep_dup\n map(&:deep_dup)\n end",
"def clone\n dup\n end",
"def unfiltered\n clone(:where => nil, :having => nil)\n end",
"def clone\n self.class.new(@attributes.except(:_id).except(:versions).dup)\n end",
"def deep_copy\n field_copy = self.dup\n field_copy.save!\n field_copy\n end",
"def children\n base_set_class.find(:all, :conditions => \"#{scope_condition} AND #{parent_col_name} = #{self.id}\", :order => left_col_name)\n end",
"def deep_dup\n Marshal.load(Marshal.dump(self))\n end",
"def all_children\n return @all_children if !@all_children.nil?\n @all_children = PhotoCollection.all_urls.find_all{|url| url[self.url] && url != self.url}.collect{|url| PhotoCollection.find_by_url(url)}\n end",
"def copy_object_set\n @objects.clone\n end",
"def subquery\n subqueries.\n compact.\n inject(&:merge)\n end",
"def __deep_copy__\n self.class.new(aliases, serializers) do |copy|\n each_pair do |key, value|\n copy.store(key, value.__deep_copy__)\n end\n end\n end",
"def deep_copy\n Expression.new(name.deep_copy, value && value.deep_copy)\n end",
"def all_children(special=nil)\n full_set(special) - [self]\n end",
"def children\n @children ||= {}.with_indifferent_access\n end",
"def clone\n super\n end",
"def initialize_copy(_original)\n new_children = {}\n @children.each do |child_name, child_group|\n new_children[child_name] = []\n child_group.each do |child|\n cloned_child = child.clone\n cloned_child.parent = self\n # cloned_child.root = @root\n new_children[child_name] << cloned_child\n end\n end\n @children = new_children\n end",
"def children\n if self.rep_parent.nil?\n return super\n else\n the_children = Array.new\n self.rep_parent.children.each do |child|\n if child.is_a?(Repeatable)\n \n child.repititions.\n where(:show_date => self.show_date).each do |r|\n the_children << r\n end\n elsif child.show_date == self.show_date\n the_children << child\n end\n end\n return the_children\n end\n end",
"def all_children\n @all_children ||= children + children.inject([]) {|records, child| records + child.all_children}\n end",
"def create_children_list\n return ArrayList.new\n end",
"def to_a\n @elements.clone\n end",
"def clone\n ret = self.deep_copy\n ret.register if self.registered\n ret\n end",
"def children\n list = NodeSet.new(document)\n document.decorate(list)\n\n first = self.child\n return list unless first # Empty list\n\n list << first unless first.blank?\n while first = first.next\n list << first unless first.blank?\n end\n list\n end",
"def clone()\n\t\ttemp = LinkedList.new()\n\t\tcurrent = @head\n\t\twhile (current)\n\t\t\ttemp.append(current.get_item())\n\t\t\tcurrent = current.get_next()\n\t\tend\n\t\treturn temp;\n\tend",
"def to_a\r\n @objs.dup\r\n end",
"def clone\n cloned = super\n # need to go to some lengths here, as Parsing::Result objects,\n # which hide behind @sentences, have important inst vars of\n # their own now and are not simply HashContainables\n parse_result = @sentences.clone;\n cloned.replace_with_clone(:sentences, :report)\n parse_result.container.merge!(cloned.sentences)\n cloned.sentences = parse_result\n cloned\n end",
"def clone\n # This is an easy fix to ruby's shameful lack of deep_copy.\n # Marshall.dump transforms any object in a string that can later be decoded to\n # yield the object back. This way, you get a deepcopy of the given object.\n # Easy but dirty.\n return Marshal.load( Marshal.dump(self) )\n end",
"def clone\n # This is an easy fix to ruby's shameful lack of deep_copy.\n # Marshall.dump transforms any object in a string that can later be decoded to\n # yield the object back. This way, you get a deepcopy of the given object.\n # Easy but dirty.\n return Marshal.load( Marshal.dump(self) )\n end",
"def to_a\n return @inner.clone\n end",
"def to_a\n return @inner.clone\n end",
"def deep_copy\n Sass::Tree::Visitors::DeepCopy.visit(self)\n end",
"def _clone\n self.class.new(self)\n end"
] | [
"0.6835412",
"0.66094726",
"0.63128006",
"0.6281369",
"0.6242736",
"0.6209777",
"0.61723334",
"0.6091195",
"0.6061811",
"0.5970495",
"0.59669834",
"0.596342",
"0.59093624",
"0.5879351",
"0.5858945",
"0.5858945",
"0.58115286",
"0.5810082",
"0.5805728",
"0.58056194",
"0.5804239",
"0.5784894",
"0.57762605",
"0.5755165",
"0.5740161",
"0.57133067",
"0.57011205",
"0.5678523",
"0.56633866",
"0.56612396",
"0.56550467",
"0.5650258",
"0.5650258",
"0.56442475",
"0.5602791",
"0.559439",
"0.5563771",
"0.556173",
"0.55529916",
"0.55381876",
"0.55356467",
"0.55238897",
"0.5516577",
"0.5506372",
"0.5496732",
"0.5472257",
"0.5466868",
"0.545855",
"0.54287505",
"0.54284376",
"0.542843",
"0.54270184",
"0.5424156",
"0.542068",
"0.5416815",
"0.5416815",
"0.5416815",
"0.5416815",
"0.5416815",
"0.54159683",
"0.5414051",
"0.5412264",
"0.5397047",
"0.539334",
"0.5384376",
"0.53753394",
"0.5371628",
"0.53638184",
"0.53578025",
"0.5353211",
"0.53473365",
"0.53451264",
"0.53408563",
"0.5339861",
"0.533872",
"0.5316483",
"0.53161526",
"0.5315545",
"0.53151214",
"0.5312724",
"0.531147",
"0.5311344",
"0.5308626",
"0.5298237",
"0.52967745",
"0.5287414",
"0.52802926",
"0.5276378",
"0.52711606",
"0.5270743",
"0.52705413",
"0.5266851",
"0.5264295",
"0.52582043",
"0.52582043",
"0.5257324",
"0.5257324",
"0.5249319",
"0.52462864"
] | 0.8258115 | 0 |
Merges this query with another. The returned query queries for the intersection between the two inputs. Both queries should be resolved. | def merge(other)
m1, t1 = resolved_modifier.downcase, resolved_type.downcase
m2, t2 = other.resolved_modifier.downcase, other.resolved_type.downcase
t1 = t2 if t1.empty?
t2 = t1 if t2.empty?
if (m1 == 'not') ^ (m2 == 'not')
return if t1 == t2
type = m1 == 'not' ? t2 : t1
mod = m1 == 'not' ? m2 : m1
elsif m1 == 'not' && m2 == 'not'
# CSS has no way of representing "neither screen nor print"
return unless t1 == t2
type = t1
mod = 'not'
elsif t1 != t2
return
else # t1 == t2, neither m1 nor m2 are "not"
type = t1
mod = m1.empty? ? m2 : m1
end
Query.new([mod], [type], other.expressions + expressions)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersect(other)\n set_operation(other, :intersect, distinct: true)\n end",
"def intersect(other)\n\t\t\tc = Xmms::Collection.new(Xmms::Collection::TYPE_INTERSECTION)\n\t\t\tc.operands << self\n\t\t\tc.operands << other\n\t\t\tc\n\t\tend",
"def intersect(other)\n Intersection.new(self, other)\n end",
"def merge(other)\n new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact\n return if new_queries.empty?\n QueryList.new(new_queries)\n end",
"def merge(other)\n new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact\n return if new_queries.empty?\n QueryList.new(new_queries)\n end",
"def intersection(other)\n self.class.from_a(to_a & other.to_a)\n end",
"def intersection(other)\n raise ArgumentError, \"value must be a #{self.class.name}\" unless other.is_a?(VersionRange)\n result = @ranges.map { |range| other.ranges.map { |o_range| range.intersection(o_range) } }.flatten\n result.compact!\n result.uniq!\n result.empty? ? EMPTY_RANGE : VersionRange.new(result, nil)\n end",
"def intersect(other)\n new(to_ary & other)\n end",
"def intersection\n self.reduce(&:intersection)\n end",
"def intersect_all(other)\n set_operation(other, :intersect, distinct: false)\n end",
"def and other_result\n result = dup\n result.matched = hash_intersection(matched, other_result.matched)\n result.not_matched = hash_intersection(not_matched, other_result.not_matched)\n result\n end",
"def intersect(other)\n intersections(other)\n .with_object(self.class.new) { |(b, e), a| a << create_item(b, e) }\n end",
"def intersection(a, b)\n negate(union(negate(a), negate(b)))\n end",
"def intersect(other)\n begin_at = self.begin >= other.begin ? self.begin : other.begin\n end_at = self.end <= other.end ? self.end : other.end\n\n begin_at <= end_at ? self.class.new(begin_at..end_at) : nil\n end",
"def intersection_with(other)\n r1,r2 = matched_range_types(self, other)\n max_begin = [r1.begin,r2.begin].max\n min_end = [r1.end, r2.end ].min\n excl = ( r1.end == min_end && \n r1.respond_to?(:exclude_end?) && r1.exclude_end?\n ) ||\n ( r2.end == min_end && \n r2.respond_to?(:exclude_end?) && r2.exclude_end?\n )\n unless max_begin > min_end\n Range.new(max_begin, min_end, excl).extend(DateTimeRange)\n end\n end",
"def fetch_intersection(json_a, json_b)\n return json_b.kind_of?(Array) ? json_a & json_b : json_a.intersection(json_b)\n end",
"def intersect(other)\n set = MyHashSet.new\n to_a.each { |el| set.insert(el) if other.include?(el) }\n set\n end",
"def intersection(another_geometry)\n raise Error::UnsupportedOperation, \"Method Geometry#intersection not defined.\"\n end",
"def intersection_of left, right\n # Using sorts may be more efficient on large sets.\n right.inject([]) { |intersect, r|\n # The select could be made more efficient.\n matches = left.select { |l| l[\"id\"] == r[\"id\"] }\n intersect.push(matches.first) if matches.any?\n intersect\n }\n end",
"def intersection(*args)\n other = coerce_range(*args)\n sorted = [self, other].sort\n\n return nil if self.class.compare(sorted[0].end, sorted[1].begin) < 0\n\n ARange[sorted[1].begin, self.class.min(sorted[1].end, sorted[0].end)]\n end",
"def intersection\n @grpc.intersection\n end",
"def intersection(set1, set2)\r\n\t# set1 and set2 are arrays\r\n\t# return the intersection\r\nend",
"def intersect _obj, _args\n \"_obj intersect _args;\" \n end",
"def intersection(other_set)\n new_set = []\n # Fill our empty array with elements that are members of both sets\n other_set.set.each do |element|\n new_set.push(element) if @set.include?(element)\n end\n Set.new(new_set)\n end",
"def intersection(other)\n mapping_function = 'lambda{|item| [item, nil]}'\n filter_function = 'lambda{|(key, values)| values.size > 1}'\n\n self.map(mapping_function)\n .cogroup(other.map(mapping_function))\n .filter(filter_function)\n .keys\n end",
"def intersection(set1, set2)\n # p set1\n # p set2\n intarray=[]\n for object in set1 #for each object in set1\n # p object\n if set2.include?(object) #check if the object is included in set2\n intarray.push(object) #if it is then push it to intarray\n end\n end\n return intarray\n\t# set1 and set2 are arrays\n\t# return the intersection\nend",
"def *(rhs)\n intersection(rhs)\n end",
"def update!(**args)\n @intersection = args[:intersection] if args.key?(:intersection)\n end",
"def intersection(nums1, nums2)\n nums1 & nums2\n end",
"def get_intersection\n end",
"def intersection(other)\n if other.is_a?(Point)\n return points_intersection(self, other)\n end\n\n if other.respond_to?(:intersection)\n return other.intersection(self)\n end\n\n raise TypeError, \"Intersection between Point and #{ other.class } is not defined\"\n end",
"def +(other)\n combined_query = JupiterCore::DeferredSimpleSolrQuery.new(nil)\n combined_query.children.<< self\n combined_query.children << other\n\n combined_query\n end",
"def subquery\n subqueries.\n compact.\n inject(&:merge)\n end",
"def union(other)\n set_operation(other, :+,\n distinct: true,\n add_boundaries: true)\n end",
"def intersect(dataset, opts=OPTS)\n raise(InvalidOperation, \"INTERSECT not supported\") unless supports_intersect_except?\n raise(InvalidOperation, \"INTERSECT ALL not supported\") if opts[:all] && !supports_intersect_except_all?\n compound_clone(:intersect, dataset, opts)\n end",
"def intersection(other)\n [first, other.begin].max..[last, other.end].min\n end",
"def merge(other)\n if include?(other.begin) || other.include?(self.begin)\n cmp = self.begin <=> other.begin\n if cmp < 0\n min = self.begin\n excl_begin = exclude_begin?\n elsif cmp > 0\n min = other.begin\n excl_begin = other.exclude_begin?\n else\n min = self.begin\n excl_begin = exclude_begin? && other.exclude_begin?\n end\n\n cmp = self.end <=> other.end\n if cmp > 0\n max = self.end\n excl_end = self.exclude_end?\n elsif cmp < 0\n max = other.end\n excl_end = other.exclude_end?\n else\n max = self.end\n excl_end = exclude_end && other.exclude_end?\n end\n\n MinMaxRange.create(excl_begin ? GtRange.new(min) : GtEqRange.new(min), excl_end ? LtRange.new(max) : LtEqRange.new(max))\n elsif exclude_end? && !other.exclude_begin? && self.end == other.begin\n # Adjacent, self before other\n from_to(self, other)\n elsif other.exclude_end? && !exclude_begin? && other.end == self.begin\n # Adjacent, other before self\n from_to(other, self)\n elsif !exclude_end? && !other.exclude_begin? && self.end.next(:patch) == other.begin\n # Adjacent, self before other\n from_to(self, other)\n elsif !other.exclude_end? && !exclude_begin? && other.end.next(:patch) == self.begin\n # Adjacent, other before self\n from_to(other, self)\n else\n # No overlap\n nil\n end\n end",
"def intersect(tenant_id,entity_type_id_1,entity_id_1,entity_type_id_2,strict_number)\n @instance.intersect(tenant_id,entity_type_id_1,entity_id_1,entity_type_id_2,strict_number)\n end",
"def intersection(range)\n cmp = self.begin <=> range.end\n if cmp > 0\n nil\n elsif cmp == 0\n exclude_begin? || range.exclude_end? ? nil : EqRange.new(self.begin)\n else\n cmp = range.begin <=> self.end\n if cmp > 0\n nil\n elsif cmp == 0\n range.exclude_begin? || exclude_end? ? nil : EqRange.new(range.begin)\n else\n cmp = self.begin <=> range.begin\n min = if cmp < 0\n range\n elsif cmp > 0\n self\n else\n self.exclude_begin? ? self : range\n end\n\n cmp = self.end <=> range.end\n max = if cmp > 0\n range\n elsif cmp < 0\n self\n else\n self.exclude_end? ? self : range\n end\n\n if !max.upper_bound?\n min\n elsif !min.lower_bound?\n max\n else\n MinMaxRange.new(min, max)\n end\n end\n end\n end",
"def containing(query)\n @query[:Query] << query\n self\n end",
"def intersect!(other)\n redis.sinterstore key, key, other.key\n ensure\n notify_changed\n end",
"def findTheIntersections\n intersection = [] #Numeros que A y B comparten\n differenceB = [] #Numeros que B tiene y no A\n differenceA =[] #Numero que A tiene y no B\n puts \"Sus intersecciones son: \"\n #Aqui se saca la interseccion \n for i in [email protected]\n if @A.include?(@B[i]) == true\n intersection.push(@B[i])\n i +=1 \n end\n end\n #Aqui solo se buscan los numeros diferentes entre A y B\n for u in [email protected]\n if @B.include?(@A[u]) == false\n differenceA.push(@A[u])\n u +=1 \n end\n end\n #Aqui solo se buscan los numeros diferentes entre B y A\n for i in [email protected]\n if @A.include?(@B[i]) == false\n differenceB.push(@B[i])\n i +=1 \n end\n end\n #Aqui se hace la union\n union = intersection + differenceA +differenceB\n #Por ultimo se imprime\n puts \"A ⋂ B = #{intersection}\"\n puts \"A ⋃ B = #{union.sort}\"\n puts \"A — B = #{differenceA}\" \n puts \"B — A = #{differenceB}\" \n end",
"def __intersect__(object)\n object.__intersect_from_array__(self)\n end",
"def intersection(b)\n @pages.delete_if { |k, v| not b.pages.include?(k) }\n self\n end",
"def merge(other)\n m1, t1 = resolved_modifier.downcase, resolved_type.downcase\n m2, t2 = other.resolved_modifier.downcase, other.resolved_type.downcase\n t1 = t2 if t1.empty?\n t2 = t1 if t2.empty?\n if ((m1 == 'not') ^ (m2 == 'not'))\n return if t1 == t2\n type = m1 == 'not' ? t2 : t1\n mod = m1 == 'not' ? m2 : m1\n elsif m1 == 'not' && m2 == 'not'\n # CSS has no way of representing \"neither screen nor print\"\n return unless t1 == t2\n type = t1\n mod = 'not'\n elsif t1 != t2\n return\n else # t1 == t2, neither m1 nor m2 are \"not\"\n type = t1\n mod = m1.empty? ? m2 : m1\n end\n q = Query.new([], [], other.expressions + expressions)\n q.resolved_type = type\n q.resolved_modifier = mod\n return q\n end",
"def intersect(other)\n @bits & bits_from_object(other)\n end",
"def merge(other)\n other = other.criteria\n\n fresh.tap do |criteria|\n [\n :profile_value, :failsafe_value, :terminate_after_value, :timeout_value, :offset_value,\n :limit_value, :scroll_args, :source_value, :preference_value, :search_type_value,\n :routing_value, :track_total_hits_value, :explain_value, :http_timeout_value\n ].each do |name|\n criteria.send(:\"#{name}=\", other.send(name)) unless other.send(name).nil?\n end\n\n [\n :sort_values, :includes_values, :preload_values, :eager_load_values, :must_values,\n :must_not_values, :filter_values, :post_must_values, :post_must_not_values,\n :post_filter_values\n ].each do |name|\n criteria.send(:\"#{name}=\", (criteria.send(name) || []) + other.send(name)) if other.send(name)\n end\n\n [:highlight_values, :suggest_values, :custom_value, :aggregation_values].each do |name|\n criteria.send(:\"#{name}=\", (criteria.send(name) || {}).merge(other.send(name))) if other.send(name)\n end\n end\n end",
"def intersect(dataset, all = false)\n clone(:intersect => dataset, :intersect_all => all)\n end",
"def merge!(query)\n if !query.is_a?(SQLQuery)\n query[:context] = @context.name unless query[:context]\n\n # If we're passed a string query to merge, it must start with\n # *; if it doesn't, we supply the leading *.\n #\n # If the caller really wants to merge a query with a nick\n # selector, they may use an explicit nick dereference:\n # '@person foo=bar' etc.\n unless query[:cmdline] =~ /^\\* /\n query[:cmdline] = '* ' + query[:cmdline]\n end\n query = SQLQuery.new(query)\n end\n QueryMerger.merge_into(self, query)\n end",
"def intersection(b)\n @cfile_by_name.each_value do |af|\n bf = b[af.file]\n if bf\n af.intersection bf\n else\n @cfile_by_name.delete af.file\n end\n end\n self\n end",
"def intersect(results_list)\n intersection_hits = self.all & results_list.all\n keywords = used_keywords | results_list.used_keywords\n \n ResultsList.new(intersection_hits, keywords.uniq)\n end",
"def bt_intersect(*args)\n where(arel_bt_intersect(*bt_temporal(*args)))\n end",
"def intersection(fa)\n perform_set_operation(:intersection, fa)\n end",
"def fully_includes?(other)\n overlaps?(other) && other == intersection(other)\n end",
"def intersect_with(recurse, transform1, entities1, transform2, hidden, entities2)\n end",
"def union(query)\n union_context = QL::QueryContext.new(self)\n union_context.register_query(query)\n union_context = QL.to_query(query, union_context)\n\n @last_query_context.union(union_context)\n self\n end",
"def intersection(another_transmembrane_domain_defintion)\n res = (@start..@stop).to_a & (another_transmembrane_domain_defintion.start..another_transmembrane_domain_defintion.stop).to_a\n res.empty? ? nil : (res.first..res.last)\n end",
"def intersection(range)\n int_a = (self.to_a & range.to_a) \n int_a.empty? ? nil : Range.new(int_a.min, int_a.max)\n end",
"def &(predicate)\n predicate.is_a?(Predicate) ? Predicate::Intersection.new(self, predicate) : self\n end",
"def intersect?(other_set)\n requires_set(other_set, __method__)\n intersection(other_set).any?\n end",
"def merge_query_objects(*query_objects)\n merged_query = {}.with_indifferent_access\n query_objects.compact.each do |query|\n query.each_pair do |facet_name, opts|\n if merged_query[facet_name].nil?\n merged_query[facet_name] = opts\n else\n opts.each_pair do |operator, values|\n values.each do |value|\n merged_query[facet_name][operator] << value unless merged_query[facet_name][operator].include?(value)\n end\n end\n end\n end\n end\n merged_query\n end",
"def intersectWithSegmentAsLineResult seg\n # self is the intersection \n self\n end",
"def intersection(other_set)\n requires_set(other_set, __method__)\n other_set.reduce([]) do |array, k|\n array << k if @internal_hash[k]\n array\n end\n end",
"def intersection(another_segment)\n return TestHalfEdge.he_intersection(@start,@ending,another_segment.start,\n another_segment.ending)\n end",
"def intersection\n\t\t\tarray = self.sort_elements\n\t\t\tarray.inject() do |common, element|\n\t\t\t\tvalue_first = comparison_value(common, :last)\n\t\t\t\tvalue_element = comparison_value(element, :first)\n\t\t\t\tcase value_first <=> value_element\n\t\t\t\twhen -1 then return nil\n\t\t\t\twhen 0 then value_first\n\t\t\t\telse\n\t\t\t\t\tif element.class == Range \n\t\t\t\t\t\tvalue_element..([value_first, comparison_value(element, :last)].min)\n\t\t\t\t\telse\n\t\t\t\t\t\tvalue_element\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def set_intersection set1, set2 \n\tresult \t\t\t= [];\n\tsec_index = 0 \n\tfirst_index = 0\n\n\twhile sec_index < set2.size && first_index < set1.size do \n\t\tif set1[first_index].to_i > set2[sec_index].to_i\n\t\t\tsec_index += 1\n\t\telsif set1[first_index].to_i == set2[sec_index].to_i\n\t\t\tresult << set1[first_index]\n\t\t\tfirst_index += 1\n\t\telsif set1[first_index].to_i < set2[sec_index].to_i\n\t\t\tfirst_index += 1\n\t\tend\n\tend\n\treturn result\nend",
"def fast_intersection(array_one, array_two)\nend",
"def tt_intersect(instant=Time.zone.now, range_end=nil)\n where(arel_tt_intersect(instant, range_end))\n end",
"def merge(other)\n if self.overlaps?(other)\n [self | other]\n else\n [self, other]\n end\n end",
"def merge!(other)\n operands[0] += other.operands[0]\n self\n end",
"def &(other)\n pp = PositionalParams.merge_for_intersection(positional_params, other.positional_params) rescue return\n kp = keyword_params & other.keyword_params or return\n Params.new(positional_params: pp, keyword_params: kp)\n end",
"def intersect(ray)\n # Must be overriden be subclasses\n end",
"def merge(changes)\n vars = @vars.merge(changes)\n\n # If the query changed, throw away the old matches so that new ones will be\n # computed.\n matches_are_stale = vars.fetch(:query) != @query\n if matches_are_stale\n vars = vars.reject { |key| key == :matches }\n end\n\n Search.new(vars)\n end",
"def merge_query\n\t\t\tp = []\n\t\t\tp << @params.query_string unless @params.query_string == \"\"\n\t\t\tp << @filters.query_string unless @filters.query_string == \"\"\n\t\t\treturn p.size > 0 ? p.join(\"&\") : nil\n\t\tend",
"def intersection(range)\n # Return self if nil (the other range has no restrictions) or if it matches the other range (they are equivalent)\n return self.clone if range.nil?\n return self.clone if eql?(range)\n\n # Figure out which range starts later (the more restrictive one)\n if low <= range.low\n earlier_start = self\n later_start = range\n else\n earlier_start = range\n later_start = self\n end\n \n # Return nil if there is no common time (the two ranges are entirely disjoint)\n return nil unless later_start.contains?(earlier_start.high)\n \n # Figure out which ranges ends earlier (the more restrictive one)\n if high >= range.high\n earlier_end = self\n later_end = range\n else\n earlier_end = range\n later_end = self\n end\n\n Range.new(\"TS\", later_start.low.clone, earlier_end.high.clone, nil)\n end",
"def merge(other); end",
"def merge!(other)\n if other.lower_bound > @lower_bound\n @lower_bound = other.lower_bound\n @include[:lower_bound] = other.include_lower_bound?\n end\n if other.upper_bound\n if @upper_bound.nil? || other.upper_bound < @upper_bound\n @upper_bound = other.upper_bound\n @include[:upper_bound] = other.include_upper_bound?\n end\n end\n self\n end",
"def merge(other)\n other.inject(self) { |result, entry| result << entry }\n end",
"def intersect( b1, b2 )\n finger1 = b1\n finger2 = b2\n\n while finger1 != finger2\n while finger1.postorder_id < finger2.postorder_id\n finger1 = @doms[ finger1.topo_id ]\n end\n while finger2.postorder_id < finger1.postorder_id\n finger2 = @doms[ finger2.topo_id ]\n end\n end\n\n return finger1\n end",
"def fast_intersection(array_one, array_two)\n\nend",
"def vt_intersect(instant=Time.zone.now, range_end=nil)\n where(arel_vt_intersect(instant, range_end))\n end",
"def intersect(xs, ys)\n result = []\n result = xs & ys\n puts result\nend",
"def includes(*args)\n fresh.tap do |criteria|\n criteria.includes_values = (includes_values || []) + args\n end\n end",
"def intersect(boundingbox)\n end",
"def intersect(nums1, nums2)\n nums1.sort!\n nums2.sort!\n\n pointer_1 = 0\n pointer_2 = 0\n\n intersection = []\n while pointer_1 < nums1.length && pointer_2 < nums2.length\n selected = nums1[pointer_1]\n while pointer_2 < nums2.length && nums2[pointer_2] < selected\n pointer_2 += 1\n end\n\n if pointer_2 >= nums2.length\n return intersection\n end\n\n count = 0\n while nums1[pointer_1] && nums2[pointer_2] && nums1[pointer_1] == nums2[pointer_2]\n count += 1\n pointer_1 += 1\n pointer_2 += 1\n end\n\n intersection += [selected] * count\n\n while nums1[pointer_1] && nums1[pointer_1] == selected\n pointer_1 += 1\n end\n end\n\n intersection\nend",
"def intersect(other_interval)\n if self.end <= other_interval.start || other_interval.end <= start\n nil\n else\n Interval.new([start, other_interval.start].max, [self.end, other_interval.end].min)\n end\n end",
"def &(other)\n # transform self into a LinkedHashSet to remove duplicates and preserve order as defined by the Ruby Array intersection contract\n duped = Java::JavaUtil::LinkedHashSet.new(self)\n duped.retainAll(other)\n duped\n end",
"def and(query = nil, *args)\n merge_query(query, :and, *args) do |left, right|\n NSCompoundPredicate.andPredicateWithSubpredicates([left, right])\n end\n end",
"def merge(other)\n other.each { |entry| self << entry }\n self\n end",
"def simple_equals_in other\n Search.alive?\n .where(query: other.query)\n .joins(:pseudo_graph_pattern)\n .where(pseudo_graph_patterns: { read_timeout: other.read_timeout })\n .where(pseudo_graph_patterns: { sparql_limit: other.sparql_limit })\n .where(pseudo_graph_patterns: { answer_limit: other.answer_limit })\n .where(pseudo_graph_patterns: { target: other.target })\n .where(pseudo_graph_patterns: { private: false })\n .order(created_at: :desc)\n .first\n end",
"def where(*args)\n execute_in_union_relations(union_relations, :where, *args)\n self\n end",
"def intersects(duration)\n return (includes(duration.beginTime) || includes(duration.endTime) ||\n duration.includes(@beginTime) || duration.includes(@endTime)) ;\n end",
"def union_all(other)\n set_operation(\n other,\n :+,\n distinct: false,\n add_boundaries: true,\n inherit_boundaries: true\n )\n end",
"def union(other_set)\n new_set = @set\n # Create an array with elements that are members of either set\n other_set.set.each do |element|\n new_set.push(element)\n end\n Set.new(new_set)\n end",
"def include(*args)\n include_or_extend(:include, *args)\n end",
"def union(other)\n set = MyHashSet.new\n (to_a + other.to_a).uniq.each { |el| set.insert(el) }\n set\n end",
"def merge(other)\n append(*other)\n end",
"def intersects_with(&block)\n [:intersects_with, block]\n end",
"def intersects_with(&block)\n [:intersects_with, block]\n end",
"def hash_array_intersection(k, merged)\n merged_str = merged[k].map(&:to_s)\n _self_str = self[k].map(&:to_s)\n intersection_str_arr = merged_str & _self_str\n return intersection_str_arr.map { |a| eval(a) }\n end"
] | [
"0.67638135",
"0.65890235",
"0.65204906",
"0.6408978",
"0.6408978",
"0.6266415",
"0.6180291",
"0.61776996",
"0.6147979",
"0.6088569",
"0.60722184",
"0.60289437",
"0.59464574",
"0.59423137",
"0.5833187",
"0.5816566",
"0.56936026",
"0.5661878",
"0.5645876",
"0.56013787",
"0.5539672",
"0.55387104",
"0.5517307",
"0.55005974",
"0.54909617",
"0.5472572",
"0.54719853",
"0.54639274",
"0.54400504",
"0.54091305",
"0.5391732",
"0.5378984",
"0.5369987",
"0.53412217",
"0.5336299",
"0.53162354",
"0.5295739",
"0.5289005",
"0.5270153",
"0.52517605",
"0.5227465",
"0.52273846",
"0.51887095",
"0.5181596",
"0.5179297",
"0.51782054",
"0.51767087",
"0.5157466",
"0.5154118",
"0.51527005",
"0.51450014",
"0.51444435",
"0.51366067",
"0.5109079",
"0.5101615",
"0.5070405",
"0.50627655",
"0.50500554",
"0.50439703",
"0.50360215",
"0.503067",
"0.50235593",
"0.5020352",
"0.50056267",
"0.5004171",
"0.500411",
"0.5002179",
"0.49837574",
"0.49713993",
"0.49548775",
"0.495419",
"0.49356487",
"0.49334604",
"0.4922429",
"0.4917932",
"0.4914083",
"0.48898065",
"0.4885331",
"0.4883519",
"0.4874975",
"0.48724228",
"0.48713887",
"0.48712128",
"0.48674563",
"0.48671204",
"0.4860912",
"0.4857984",
"0.48499414",
"0.48458478",
"0.48369658",
"0.48342335",
"0.48223996",
"0.4819924",
"0.48058408",
"0.4799983",
"0.4794268",
"0.47617793",
"0.47615388",
"0.47615388",
"0.47608444"
] | 0.5070247 | 56 |
Returns the CSS for the media query. | def to_css
css = ''
css << resolved_modifier
css << ' ' unless resolved_modifier.empty?
css << resolved_type
css << ' and ' unless resolved_type.empty? || expressions.empty?
css << expressions.map do |e|
# It's possible for there to be script nodes in Expressions even when
# we're converting to CSS in the case where we parsed the document as
# CSS originally (as in css_test.rb).
e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.to_sass : c.to_s}.join
end.join(' and ')
css
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_css\n queries.map {|q| q.to_css}.join(', ')\n end",
"def to_css\n queries.map {|q| q.to_css}.join(', ')\n end",
"def css(query)\n\t\treturn is_valid ? @doc.css(query) : nil\n\tend",
"def css\n Sass::Tree::Visitors::ToCss.new.visit(self)\n end",
"def css_render\n css_list.join(\"\\n\")\n end",
"def style\n `$q(this.__native__.style.cssText)`\n end",
"def css\n @css ||= assemble_css\n end",
"def css_styles\n end",
"def css_styles\n @css_styles ||= []\n end",
"def find_css\n @dom.css(STYLE_ELEMENT_QUERY).map { |element| read_stylesheet(element) }.compact\n end",
"def style\n return \"\" if self.class.styles_pool.blank?\n\n common_style = self.class.styles_pool[:_common] || []\n common_style_without_fill_window = common_style - [FILL_WINDOW_CSS]\n if screen = params.try(:[], :screen)\n screen_style = self.class.styles_pool[screen] || []\n (screen_style.blank? ? common_style : (common_style_without_fill_window + screen_style)).uniq.join(\" \")\n else\n common_style.join(\" \")\n end\n end",
"def printCSS\r\n css=\"<style type=\\\"text/css\\\">\\n\" \r\n @concreteInterfaceIds.each do\r\n |concrete_interface|\r\n concrete_interface = SWUI::ConcreteInterface.find_by.interface_name(concrete_interface).execute.first.concrete_interface_code.first\r\n css << concrete_interface\r\n css << \"\\n\"\r\n end\r\n @ajaxcontrolIds.each do\r\n |ajaxcontrolId|\r\n ajaxcontrol = SWUI::RichControl.find_by.concrete_widget_name(ajaxcontrolId).execute.first\r\n cssCode = ajaxcontrol.cssCode.first\r\n css << \"#{cssCode}\\n\"\r\n end\r\n css << \"</style>\\n\"\r\n return css\r\n end",
"def css; end",
"def css; end",
"def css; end",
"def get_calculated_style( query, style )\n #begin assemble javascript\n script = \"return jQuery('\"\n \n #selector query\n script << \"#{query}\"\n script << \"').css('\"\n \n #css styles to verify\n script << \"#{style}\"\n script << \"');\"\n \n begin\n return @wd.execute_script(\"#{script}\")\n rescue Selenium::WebDriver::Error::JavascriptError\n return \"Unable to obtain\"\n end\n end",
"def render_style(text, mediatype=\"all\")\n [\"<style type='text/css' media='#{mediatype}' >\",\n text,\n \"</style>\\n\"].join(\"\\n\") \n end",
"def css\n options.fetch :css, CSS_SELECTOR\n end",
"def get_css_classes(output, post)\n # here we contruct the css classes to add to the media\n # we don't add zurb foundation flex-video tags for mp3 embeds\n css_classes = \"flex-video widescreen\" unless post.url[-4..-1] == \".mp3\"\n css_classes = css_classes + \" youtube\" if output.include? \"youtube.com\"\n css_classes = css_classes + \" vimeo\" if output.include? \"vimeo.com\"\n # Reset classes for images\n css_classes = \"image\" if post.url[-4..-1] == \".jpg\" or post.url[-4..-1] == \".gif\" or post.url[-4..-1] == \".png\" or post.url[-5..-1] == \".jpeg\"\n return css_classes\n end",
"def css css_selector\n @scene.get_root.lookup_all(css_selector).map {|e| e}\n end",
"def media_colors\n return @media_colors\n end",
"def css_class\n result = [self.project.try(:css_class), self.try(:format).try(:css_class)].join(' ')\n result = 'other' unless CSS_CLASSES.include?(result)\n result += ' invisible' unless self.is_visible\n result\n end",
"def style\n \"#{width}px;height:#{height}px;#{@style}\"\n end",
"def embed_code_css\n if video? || image? || interactive_map?\n responsive_embed_code_css\n elsif audio?\n audio_embed_code_css\n end\n end",
"def css_class\n end",
"def render_css\r\n @css\r\nend",
"def styles\n mentos(:get_all_styles)\n end",
"def extract_css\n @dom.css(STYLE_ELEMENT_QUERY).map { |element|\n stylesheet = read_stylesheet(element)\n element.remove if stylesheet\n stylesheet\n }.compact\n end",
"def rmq_style_applied\n on_styled\n end",
"def answer_css\n %(#answer-#{@answer.id})\n end",
"def as_css_size\n size = self\n size += 'px' unless size.blank? || size.end_with?('px', '%', 'em') || size == 'auto' || size == 'inherit'\n return size\n end",
"def css_path; end",
"def css_path; end",
"def to_css\n css = ''\n css << resolved_modifier\n css << ' ' unless resolved_modifier.empty?\n css << resolved_type\n css << ' and ' unless resolved_type.empty? || expressions.empty?\n css << expressions.map {|e| e.to_css}.join(' and ')\n css\n end",
"def render\n perform(Environment.new).cssize.to_s\n end",
"def styles\n return @metadata[:styles]\n end",
"def syntax\n :scss\n end",
"def get_stylesheet\n @stylesheet\n end",
"def inline_styles\n parser.css(\"style\").to_a\n end",
"def css(selector)\n raise NotImplementedError, 'query by CSS selector unsupported'\n end",
"def responsive_embed_code_css\n <<~END\n #fulcrum-embed-outer-#{id} {\n width:auto;\n page-break-inside:avoid;\n -webkit-column-break-inside:avoid;\n break-inside:avoid;\n max-width:#{embed_width}px;\n margin:auto;\n background-color:#000;\n }\n #fulcrum-embed-inner-#{id} {\n overflow:hidden;\n padding-bottom:#{padding_bottom}%;\n position:relative; height:0;\n }\n iframe#fulcrum-embed-iframe-#{id} {\n overflow:hidden;\n border-width:0;\n left:0; top:0;\n width:100%;\n height:100%;\n position:absolute;\n }\n END\n end",
"def gen_css(levels, minmax)\n # Header\n css = CSS_HEADER\n\n # Disable everything to start with \n levels.times{|l|\n css += \"\\n.#{class_name(l)}{ display: none; }\"\n }\n \n # Compute the various widths' display rules\n step = (minmax[MAX] - minmax[MIN]) / levels\n levels.times{|x|\n css += \"\\n@media (min-width: #{ x*step + minmax[MIN] }){\"\n (x+1).times{|l|\n css += \"\\n.#{class_name(l)}{ display: inline; }\"\n }\n css += \"\\n}\"\n }\n\n # Return with the end <script>\n return css + CSS_FOOTER\nend",
"def style\n return @style\n end",
"def css_class\n @css_class ||= \"project #{status.gsub(' ','-').downcase}\"\n end",
"def inline_css(name)\n sprockets[\"#{name}.css\"].to_s\n end",
"def stylesheets\n @parts.values.map(&:stylesheet).compact\n end",
"def netzke_css\n %{\n <style type=\"text/css\" media=\"screen\">\n #{content_for(:netzke_css)}\n </style>} if content_for(:netzke_css).present?\n end",
"def css_classes\n s = \"meeting status-#{status}\"\n s << ' created-by-me' if User.current.logged? && author_id == User.current.id\n s\n end",
"def render\n result, extends = Visitors::Cssize.visit(Visitors::Perform.visit(self))\n result = result.do_extend(extends) unless extends.empty?\n result.to_s\n end",
"def css_class\n @css_class ||= [\"project\", status.gsub(' ','-').downcase, (hideable? ? \"hideable\" : nil)].compact.join(\" \")\n end",
"def css\n project_file_read(\"all.css\")\nend",
"def gridmaxwidths ()\n # write a media query for each breakpoint\n $g = 0\n items = MEASURES\n $LEN = items.length\n $buffer = \"\"\n\n until $g == $LEN\n if $g == 0\n $NAME = 0\n $NAMETXT = \"default\"\n else\n $NAME = \"$bp-\" + items[$g]['NAME']\n $NAMETXT = $NAME\n end\n $FROM = items[$g]['FROM']\n $MAXW = items[$g]['MAXW']\n $buffer += \"\n /* #$NAMETXT breakpoint (#$FROM) */\n @media (min-width: #$NAME){\n .wrapbox {\n max-width: #$MAXW; \n }\n }\n \"\n\n $g += 1\n end\n\n return $buffer\nend",
"def css_code\n '<style type=\"text/css\">' <<\n asset('webconsole.css') <<\n '</style>'\n end",
"def styles; end",
"def styles; end",
"def styles; end",
"def css_tags\n css.map do |url|\n \"<link href=\\\"#{url}\\\" media=\\\"all\\\" rel=\\\"stylesheet\\\" type=\\\"text/css\\\" />\"\n end.join(\"\\n\")\n end",
"def css_with_sourcemap\n visitor = Sass::Tree::Visitors::ToCss.new(:build_source_mapping)\n result = visitor.visit(self)\n return result, visitor.source_mapping\n end",
"def style\n File.read(@folder + \"/data/style.css\")\n end",
"def style\n @style\n end",
"def to_css\n styles = []\n %w( chessboard mini-chessboard ).each do |board_class|\n if light_square_color\n styles << \"\n .#{board_class} .square.light {\n background: #{light_square_color} !important;\n }\n .#{board_class} .square .square-label.dark {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-white coords.ranks coord:nth-child(2n + 1) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-white coords.files coord:nth-child(2n + 1) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-black coords.ranks coord:nth-child(2n) {\n color: #{light_square_color} !important;\n }\n .cg-wrap.orientation-black coords.files coord:nth-child(2n) {\n color: #{light_square_color} !important;\n }\n \"\n end\n if dark_square_color\n styles << \"\n .#{board_class} .square.dark {\n background: #{dark_square_color} !important;\n }\n .#{board_class} .square .square-label.light {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-white coords.ranks coord:nth-child(2n) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-white coords.files coord:nth-child(2n) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-black coords.ranks coord:nth-child(2n + 1) {\n color: #{dark_square_color} !important;\n }\n .cg-wrap.orientation-black coords.files coord:nth-child(2n + 1) {\n color: #{dark_square_color} !important;\n }\n \"\n end\n if light_square_color || dark_square_color\n board_svg = %(\n <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n <svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:x=\"http://www.w3.org/1999/xlink\"\n viewBox=\"0 0 8 8\" shape-rendering=\"crispEdges\">\n <g id=\"a\">\n <g id=\"b\">\n <g id=\"c\">\n <g id=\"d\">\n <rect width=\"1\" height=\"1\" fill=\"#{light_square_color || \"#F3E4CF\"}\" id=\"e\"/>\n <use x=\"1\" y=\"1\" href=\"#e\" x:href=\"#e\"/>\n <rect y=\"1\" width=\"1\" height=\"1\" fill=\"#{dark_square_color || \"#CEB3A2\"}\" id=\"f\"/>\n <use x=\"1\" y=\"-1\" href=\"#f\" x:href=\"#f\"/>\n </g>\n <use x=\"2\" href=\"#d\" x:href=\"#d\"/>\n </g>\n <use x=\"4\" href=\"#c\" x:href=\"#c\"/>\n </g>\n <use y=\"2\" href=\"#b\" x:href=\"#b\"/>\n </g>\n <use y=\"4\" href=\"#a\" x:href=\"#a\"/>\n </svg>\n ).strip\n base64_board_svg = Base64.encode64(board_svg).gsub(/\\n/, '').strip\n styles << \"\n cg-board {\n background-image: url('data:image/svg+xml;base64,#{base64_board_svg}');\n }\n \"\n end\n if selected_square_color\n styles << \"\n .#{board_class} .square[data-selected] {\n background: #{selected_square_color} !important;\n }\n cg-board square.selected {\n background: #{selected_square_color} !important;\n }\n \"\n end\n if opponent_from_square_color\n styles << \"\n .#{board_class} .square[data-from] {\n background: #{opponent_from_square_color} !important;\n }\n .#{board_class} .square.move-from {\n background: #{opponent_from_square_color} !important;\n }\n cg-board square.last-move.move-from {\n background-color: #{opponent_from_square_color} !important;\n }\n \"\n end\n if opponent_to_square_color\n styles << \"\n .#{board_class} .square[data-to] {\n background: #{opponent_to_square_color} !important;\n }\n .#{board_class} .square.move-to {\n background: #{opponent_to_square_color} !important;\n }\n cg-board square.last-move.move-to {\n background-color: #{opponent_to_square_color} !important;\n }\n \"\n end\n end\n return unless styles.length > 0\n styles.join(\"\\n\").html_safe\n end",
"def styles\n @styles ||= DEFAULT_STYLES\n end",
"def minify_css(content)\n @css_cache[content] ||= begin\n root = SassC::Engine.new(content, @options[:sass_options])\n root.render.rstrip\n end\n end",
"def stylesheet\n @stylesheet ||= Dir.glob(root+'/**/parts.*css').first\n end",
"def media_sizes\n return @media_sizes\n end",
"def media\n return @media\n end",
"def to_css\n css = '('\n css << resolved_name\n css << ': ' << resolved_value unless resolved_value.empty?\n css << ')'\n css\n end",
"def css_config\n {\n css: {\n properties: %w(content counter-increment counter-reset counter-set list-style-type)\n }\n }\n end",
"def build_imagecss\n return unless options.Build_Image_Width_Css\n\n puts_cyan \"Middlemac is creating `#{options.File_Image_Width_Css}`.\"\n\n out_array = []\n\n Dir.glob(\"#{app.source}/Resources/**/*.{jpg,png,gif}\").each do |fileName|\n # fileName contains complete path relative to this script.\n # Get just the name and extension.\n base_name = File.basename(fileName)\n\n # width\n if File.basename(base_name, '.*').end_with?('@2x')\n width = (FastImage.size(fileName)[0] / 2).to_i.to_s\n else\n width = FastImage.size(fileName)[0].to_s;\n end\n\n # proposed css\n out_array << \"img[src$='#{base_name}'] { max-width: #{width}px; }\"\n end\n\n File.open(options.File_Image_Width_Css, 'w') { |f| out_array.each { |line| f.puts(line) } }\n\n end",
"def make_css\n template = ERB.new TEMPLATE\n result = template.result binding\n (0..3).each { result.gsub!(/\\n;\\n/m, \";\\n\") }\n @result = result.gsub /^$\\n/, ''\n end",
"def css_options\n css_keys = [:compress, :optimization, :silent, :color]\n Hash[less_options.to_enum.to_a.select{|k, _| css_keys.include? k}]\n end",
"def styles\n @document.styles\n end",
"def getStyleName\n styleNameHelper(MODE_GET)\n end",
"def media_config\n return @media_config\n end",
"def css(name, value=nil)\n if value.nil? && name.is_a?(String)\n return `self.css(name)`\n else\n name.is_a?(Hash) ? `self.css(#{name.to_n})` : `self.css(name, value)`\n end\n self\n end",
"def stylesheet\n @stylesheet.nil? ? 'gimli.css' : @stylesheet\n end",
"def css_class\n Meal.css_class_for_type(type)\n end",
"def css_classes\n css_classes = []\n css_classes << 'not-read' unless read\n css_classes << 'important' if important\n css_classes.join(' ')\n end",
"def link_css(path, media = \"screen\")\n path = \"/#{path}\" unless path =~ %r{^/}\n path = \"#{path}.css\" unless path =~ %r{\\.css$}\n %{<link href=\"#{timestamp_asset(path)}\" media=\"#{media}\" rel=\"Stylesheet\" type=\"text/css\" />}\n end",
"def style\n self\n end",
"def get_stylesheet\n # Filters the name of current stylesheet.\n apply_filters('stylesheet', get_option('stylesheet'))\n end",
"def media_type\n @media_type || parse_and_return(:@media_type)\n end",
"def syntax\n\t\t\t\t:scss\n\t\t\tend",
"def responsive_desktop_time_in_ms\n return @responsive_desktop_time_in_ms\n end",
"def responsive_desktop_time_in_ms\n return @responsive_desktop_time_in_ms\n end",
"def CssHeredoc()\n css = <<-CSS\n# ^^^ meta.string.heredoc.ruby punctuation.definition.heredoc.ruby\n# ^^ meta.string.heredoc.ruby meta.tag.heredoc.ruby entity.name.tag.ruby\n\n .class[att=#{@ruby_sel}] {\n# ^^^^^^^^^^^^ meta.string.heredoc.ruby source.css.embedded.ruby meta.selector.css meta.interpolation.ruby\n\n font-family: #{@ruby_font};\n# ^^^^^^^^^^^^^ meta.string.heredoc.ruby source.css.embedded.ruby meta.property-list.css meta.property-value.css meta.interpolation.ruby\n }\n CSS\n# ^^^ meta.string.heredoc.ruby meta.tag.heredoc.ruby entity.name.tag.ruby\nend",
"def fullscreen_sizes\n \"(min-width: #{fullscreen_max_width}px) #{fullscreen_max_width}px, 100vw\"\n end",
"def media_quality_list\n return @media_quality_list\n end",
"def syntax\n :sass\n end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def initialize_css_style_conversion; end",
"def css_status(status = nil)\n CSS_STATUSES[status || object.status]\n end",
"def media_styles_croppable_list\n list = Ubiquo::Config.context(:ubiquo_media).get(:media_styles_list)\n # The main styles are not croppable as they belong to the core\n Ubiquo::Config.context(:ubiquo_media).get(:media_core_styles).each do |s|\n list.delete(s)\n end\n # Filter the formats that are not strings like \"300x200#\"\n list.delete_if{|k,v| !v.respond_to?( :match )}\n list\n end",
"def board_material\n Board.style\n end",
"def css(url=\"\")\n self.style_sheet(url)\n end",
"def custom_css\n File.read file_path(\"#{name}.css\") if custom_css?\n end",
"def css(selector)\n @doc.css(selector)\n end"
] | [
"0.6234313",
"0.6234313",
"0.60894257",
"0.5817209",
"0.5793036",
"0.5729869",
"0.5691349",
"0.56565017",
"0.54895437",
"0.54452384",
"0.5416019",
"0.5335661",
"0.5329268",
"0.5329268",
"0.5329268",
"0.5321578",
"0.53081816",
"0.53059435",
"0.5300194",
"0.52846247",
"0.52781266",
"0.51810604",
"0.51271564",
"0.51261246",
"0.5101268",
"0.50992155",
"0.5042118",
"0.5012329",
"0.5007935",
"0.49984607",
"0.49674922",
"0.49668923",
"0.49668923",
"0.49418417",
"0.48860264",
"0.48835337",
"0.48823592",
"0.48794863",
"0.48770723",
"0.48712",
"0.48494825",
"0.4849202",
"0.48473817",
"0.4833557",
"0.48235312",
"0.48076096",
"0.47932848",
"0.47912621",
"0.4780786",
"0.4779893",
"0.47788444",
"0.4774917",
"0.47748956",
"0.47746685",
"0.47746685",
"0.47746685",
"0.47743964",
"0.4759739",
"0.47566712",
"0.47521874",
"0.47489503",
"0.47281155",
"0.472497",
"0.4723693",
"0.47126943",
"0.46964797",
"0.4694347",
"0.46857506",
"0.4675945",
"0.46695128",
"0.46674678",
"0.46562916",
"0.46508887",
"0.46478647",
"0.46393028",
"0.46364063",
"0.4634332",
"0.46331623",
"0.4624551",
"0.46243188",
"0.4621472",
"0.4612288",
"0.46022648",
"0.4592471",
"0.4592471",
"0.45841324",
"0.45831504",
"0.4582467",
"0.45751175",
"0.4568994",
"0.4568994",
"0.4568994",
"0.4568994",
"0.45657337",
"0.4556591",
"0.45519745",
"0.45462215",
"0.45429552",
"0.4539861",
"0.45332593"
] | 0.52532005 | 21 |
Returns a deep copy of this query and all its children. | def deep_copy
Query.new(
modifier.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
type.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}})
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deep_copy\n QueryList.new(queries.map {|q| q.deep_copy})\n end",
"def deep_copy\n QueryList.new(queries.map {|q| q.deep_copy})\n end",
"def clone\n q = super\n q.attrs = self.attrs.clone\n return q\n end",
"def deep_copy\n Query.new(\n modifier.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},\n type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},\n expressions.map {|q| q.deep_copy})\n end",
"def shallow_clone\n cloned = self.clone\n cloned.remove_relations\n return cloned\n end",
"def deep_clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_clone\n Marshal::load(Marshal.dump(self))\n end",
"def deep_clone\n cloned = self.clone\n cloned.initialize_from_copy(self)\n cloned\n end",
"def deep_clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_clone\n Marshal::load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n deep_transform_values(&method(:_deep_copy))\n end",
"def initialize_copy(original)\n super\n @query = @query.dup\n @cache = @cache.dup\n @orphans = @orphans.dup\n end",
"def deep_copy\r\n Marshal.load(Marshal.dump(self))\r\n end",
"def deep_copy\n Marshal.load(Marshal.dump(self))\n end",
"def deep_clone; Marshal::load(Marshal.dump(self)); end",
"def clone\n rContext = Context.new\n\n rContext.mergeWithContext(self)\n\n return rContext\n end",
"def clone\n copy = super\n copy.expressions = @expressions.map {|e| e.clone }\n copy\n end",
"def __deep_copy__\n self.class.new(aliases, serializers, associations, aliased_associations) do |copy|\n each_pair do |key, value|\n copy.merge!(key => value.__deep_copy__)\n end\n end\n end",
"def deepcopy\n\t\tMarshal.load(Marshal.dump(self))\n\tend",
"def copy(query)\n queries << query\n end",
"def clone\n obj = super\n elements = @elements.clone\n obj.instance_eval { @elements = elements }\n return obj\n end",
"def __deep_copy__\n self.class.new(aliases) do |copy|\n each do |entry|\n copy.push(entry.__deep_copy__)\n end\n end\n end",
"def deep_clone; end",
"def clone\n self.copy\n end",
"def clone\n self.copy\n end",
"def clone\n return Marshal.load(Marshal.dump(self))\n end",
"def copy\n\t\t\treturn self.dup\n\t\tend",
"def clone\n new_set = TreeSet.new\n # Create new nodes in the same order as self's\n if root\n root.root_traverse do |node|\n new_set << node.value\n end\n end\n new_set\n end",
"def deep_copy\n copy = self.dup\n copy.create_command\n copy.serializer = self.serializer.deep_copy\n copy.deserializer = self.deserializer.deep_copy\n copy.commands = self.commands.dup\n copy.libraries = self.libraries.dup\n copy.bound_objects = self.bound_objects.dup\n copy\n end",
"def clone\n @clone ||= super\n end",
"def deep_clone\n bi = dup\n bi.save\n feature_selections.each { |fs| bi.feature_selections << fs.dup }\n bi\n end",
"def clone\n copy = super\n copy.members = @members.map {|m| m.clone }\n copy\n end",
"def clone\n self\n end",
"def all_children(scope = {})\n full_set(scope) - [self]\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def clone\n Marshal.load(Marshal.dump(self))\n end",
"def deep_dup\n Marshal.load(Marshal.dump(self))\n end",
"def deep_copy\n Expression.new(name.deep_copy, value && value.deep_copy)\n end",
"def clone\n self.class.new(@parent, @position)\n end",
"def deep_copy\n field_copy = self.dup\n field_copy.save!\n field_copy\n end",
"def clone\n self.class.new(@attributes.except(:_id).except(:versions).dup)\n end",
"def all(query = nil)\n if query.nil? || (query.kind_of?(Hash) && query.empty?)\n # TODO: after adding Enumerable methods to Model, try to return self here\n new_collection(self.query)\n else\n new_collection(scoped_query(query))\n end\n end",
"def unfiltered\n clone(:where => nil, :having => nil)\n end",
"def clone\n clause_cluster = ClauseCluster.new\n clause_cluster.lhs = self.lhs.clone\n clause_cluster.rhs = self.rhs.clone\n clause_cluster.operator = self.operator\n return clause_cluster\n end",
"def deep_clone\n if RUBY_PLATFORM == 'opal'\n JSON.parse(to_json)\n else\n Marshal.load(Marshal.dump(self))\n end\n end",
"def select_all\n clone(:select => nil)\n end",
"def deep_copy\n Sass::Tree::Visitors::DeepCopy.visit(self)\n end",
"def recursive_clone\n\t\t\tnode_map = self.survey.node_maps.build(:survey => self.survey, :node => self.node)\n\t\t\tself.survey.node_maps.select { |i| i.parent == self && !i.marked_for_destruction? }.each { |child_node|\n\t\t\t\tchild_node.survey = self.survey # required due to voodoo - we want to use the same survey with the same object_id\n\t\t\t\tnode_map.children << child_node.recursive_clone\n\t\t\t}\n\t\t\tnode_map\n\t\tend",
"def clone_deep\n c = self.clone :include => collection_details\n c.updated_at = nil\n c.created_at = nil\n self.collection_details.each do |detail|\n c.send(detail).each do |d|\n d.created_at = nil\n d.updated_at = nil\n d.person_id = nil\n end\n end\n c\n end",
"def __deep_copy__\n self.class.new(aliases, serializers) do |copy|\n each_pair do |key, value|\n copy.store(key, value.__deep_copy__)\n end\n end\n end",
"def deep_copy(**options)\n copy = self.dup\n copy.question_id = options.fetch(:question_id, nil)\n return copy\n end",
"def clone\n newobj = super\n newobj.instance_eval do\n __getobj__.each_pair do |k, v|\n __getobj__[k] = v.clone\n end\n end\n newobj\n end",
"def __deep_copy__\n map { |value| value.__deep_copy__ }\n end",
"def deepCopy()\n\t\treturn Marshal::load(Marshal.dump(self))\n\tend",
"def deepCopy()\n\t\treturn Marshal::load(Marshal.dump(self))\n\tend",
"def _clone\n self.class.new(self)\n end",
"def initialize_copy(_original)\n new_children = {}\n @children.each do |child_name, child_group|\n new_children[child_name] = []\n child_group.each do |child|\n cloned_child = child.clone\n cloned_child.parent = self\n # cloned_child.root = @root\n new_children[child_name] << cloned_child\n end\n end\n @children = new_children\n end",
"def deep_clone\n return @deep_cloning_obj if @deep_cloning\n @deep_cloning_obj = clone\n @deep_cloning_obj.instance_variables.each do |var|\n val = @deep_cloning_obj.instance_variable_get(var)\n begin\n @deep_cloning = true\n val = val.deep_clone\n rescue TypeError, NoMethodError\n next\n ensure\n @deep_cloning = false\n end\n @deep_cloning_obj.instance_variable_set(var, val)\n end\n deep_cloning_obj = @deep_cloning_obj\n @deep_cloning_obj = nil\n deep_cloning_obj\n end",
"def build(attrs = {})\n @parent.new(@query_attrs.merge(attrs))\n end",
"def clone\n # This is an easy fix to ruby's shameful lack of deep_copy.\n # Marshall.dump transforms any object in a string that can later be decoded to\n # yield the object back. This way, you get a deepcopy of the given object.\n # Easy but dirty.\n return Marshal.load( Marshal.dump(self) )\n end",
"def clone\n # This is an easy fix to ruby's shameful lack of deep_copy.\n # Marshall.dump transforms any object in a string that can later be decoded to\n # yield the object back. This way, you get a deepcopy of the given object.\n # Easy but dirty.\n return Marshal.load( Marshal.dump(self) )\n end",
"def copy\n copy = self.clone\n copy.delete_all\n @collection.each do |obj|\n copy.add_param(obj.key,obj.value,obj.type)\n end\n return copy\n end",
"def subquery\n subqueries.\n compact.\n inject(&:merge)\n end",
"def clone\n copy = super\n transaction do\n copy.save!\n\n %w[\n registration_information support information_source advance_directive\n ].each do |assoc|\n copy.send(\"#{assoc}\\=\", send(assoc).clone) if send(assoc)\n end\n\n %w[\n patient_identifiers languages providers medications allergies conditions\n all_results immunizations encounters procedures medical_equipments social_history insurance_providers\n ].each do |assoc|\n send(assoc).each do |item|\n copy.send(assoc) << item.clone\n end\n end\n\n end\n copy\n end",
"def custom_deep_clone\n value = self.clone\n return Marshal.load(Marshal.dump(value))\n end",
"def deep_clone!\n opts = {}\n opts[:except] = [ \n :updated_at\n ]\n self.clone(opts) \n end",
"def clone\n ret = self.deep_copy\n ret.register if self.registered\n ret\n end",
"def dup_tree\n return @tree.dup\n end",
"def deep_copy\n copy = dup\n copy.values = {}\n @values.each { |k, v| copy.values[k] = v.clone }\n copy\n end",
"def query_full\n query = @initial_query.dup\n\n # restrict to select columns\n query = query_projection(query)\n\n #filter\n query = query_filter(query)\n\n # sorting\n query = query_sort(query)\n\n # paging\n query_paging(query)\n end",
"def clone\n cloned = super\n # need to go to some lengths here, as Parsing::Result objects,\n # which hide behind @sentences, have important inst vars of\n # their own now and are not simply HashContainables\n parse_result = @sentences.clone;\n cloned.replace_with_clone(:sentences, :report)\n parse_result.container.merge!(cloned.sentences)\n cloned.sentences = parse_result\n cloned\n end",
"def reverse\n reversed = super\n reversed.instance_variable_set(:@query, query.reverse)\n reversed\n end",
"def clone\n dup\n end",
"def children\n dataset.nested.filter(self.class.qualified_parent_column => self.id)\n end",
"def where(attrs = {})\n return self if attrs.blank?\n self.clone.tap do |r|\n r.query_attrs = r.query_attrs.merge(attrs)\n r.clear_fetch_cache!\n end\n end",
"def query_builder\n QueryBuilder.new(self)\n end",
"def to_a\n return @inner.clone\n end",
"def to_a\n return @inner.clone\n end",
"def full_set(options = {})\n return [self] if new_record? or self[nested_set_right]-self[nested_set_left] == 1\n [self] + all_children(options)\n end",
"def clone\n super\n end",
"def clone\n Marshal.load(Marshal.dump self)\n end",
"def children\n base_set_class.find(:all, :conditions => \"#{scope_condition} AND #{parent_col_name} = #{self.id}\", :order => left_col_name)\n end",
"def clone\n copy(false)\n end",
"def all_children(options = {})\n conditions = \"(#{nested_set_left} > #{self[nested_set_left]}) and (#{nested_set_right} < #{self[nested_set_right]})\"\n if options[:exclude]\n transaction do\n # exclude some items and all their children\n options[:exclude] = [options[:exclude]] if !options[:exclude].is_a?(Array)\n # get objects for ids\n options[:exclude].collect! {|s| s.is_a?(nested_set_class) ? s : nested_set_class.find(s)}\n # get all subtrees and flatten the list\n exclude_list = options[:exclude].map{|e| e.full_set.map{|ee| ee.id}}.flatten.uniq\n conditions += \" AND id NOT IN (#{exclude_list.join(',')})\" unless exclude_list.empty?\n end\n end\n nested_set_class.find_with_nested_set_scope(:all, :conditions => conditions, :order => nested_set_left)\n end",
"def self_and_descendants_from_active_record\n [self]\n end",
"def to_ary\n @descendants.dup\n end",
"def to_recursive\n self\n end",
"def copy_object_set\n @objects.clone\n end",
"def clone\n bag_clone = Bag.new\n bag_clone.copy_all(self)\n bag_clone\n end",
"def descendants\n return [] if new_record?\n tree_search_class.where(tree_path_field => self._id).sort(self.class.tree_sort_order()).all\n end",
"def self_and_descendants_from_active_record\n [self]\n end",
"def clone( options={} )\n\t\tself.log.debug \"cloning %p with options = %p\" % [ self, options ]\n\t\tnewset = super()\n\t\tnewset.options = @options.merge( options )\n\t\treturn newset\n\tend",
"def children\n self.class.find(:all, :conditions => \"#{acts_as_nested_set_options[:scope]} AND #{acts_as_nested_set_options[:parent_column]} = #{self.id}\", :order => acts_as_nested_set_options[:left_column])\n end",
"def clone\n o = dup\n o.freeze if frozen?\n o\n end"
] | [
"0.75652254",
"0.75652254",
"0.72111434",
"0.6724821",
"0.6652218",
"0.65483296",
"0.6526057",
"0.65101665",
"0.6416113",
"0.6393255",
"0.62028533",
"0.6183667",
"0.6183667",
"0.6167999",
"0.6119969",
"0.61152375",
"0.6106077",
"0.6083217",
"0.59995073",
"0.5968258",
"0.5932137",
"0.5880957",
"0.5852502",
"0.583927",
"0.5832719",
"0.5829072",
"0.58261603",
"0.58261603",
"0.580937",
"0.57740337",
"0.5766588",
"0.5736414",
"0.5736017",
"0.569172",
"0.5688853",
"0.5683973",
"0.5675849",
"0.5670302",
"0.5670302",
"0.5670302",
"0.5670302",
"0.5670302",
"0.5668396",
"0.5659075",
"0.5652017",
"0.56454104",
"0.5634347",
"0.5627435",
"0.56164944",
"0.56127137",
"0.5611136",
"0.5579941",
"0.5575411",
"0.5574313",
"0.55591166",
"0.5549601",
"0.5536014",
"0.55168533",
"0.5513958",
"0.55086577",
"0.55086577",
"0.5506641",
"0.54967314",
"0.54951704",
"0.5492602",
"0.54770833",
"0.54770833",
"0.54743254",
"0.5469742",
"0.5468471",
"0.5465773",
"0.5458305",
"0.5455207",
"0.5441899",
"0.5436294",
"0.5431211",
"0.5405112",
"0.54000735",
"0.5396189",
"0.5395915",
"0.5395105",
"0.53947085",
"0.5387889",
"0.5387889",
"0.5368112",
"0.5365665",
"0.53587526",
"0.53537416",
"0.5350281",
"0.5343242",
"0.53394306",
"0.5331056",
"0.5326243",
"0.532",
"0.5317047",
"0.53168654",
"0.5308104",
"0.53047854",
"0.5292151",
"0.52831286"
] | 0.7017192 | 3 |
solution number 2 with bitwise XOR operator | def stray(numbers)
numbers.reduce(&:^)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xor_b\n end",
"def xor(a,b)\n (a | b) - (a & b)\n end",
"def xor_c\n end",
"def xor(x, y)\n\nend",
"def xor_l\n end",
"def xor_e\n end",
"def xor_d\n end",
"def xor_a\n end",
"def xor_d8\n end",
"def xor(argument1, argument2)\n argument1 && !argument2 || !argument1 && argument2\n end",
"def xor?(num1,num2)\n if num1 == true && num2 == false\n return true\n elsif num1 == false && num2 == true\n return true\n else\n return false\n end\nend",
"def p1(x, y, z)\n # x or y\n xor(x, y)\nend",
"def xor(e1, e2)\n eval_ex(e1) ^ eval_ex(e2)\n end",
"def bitwise_xor(num1, num2)\n bnum1 = num1.to_s(2)\n bnum2 = num2.to_s(2)\n band = (num1 | num2).to_s(2)\n puts \"num1 = \" + ( ' ' * bnum2.length ) + num1.to_s(2)\n puts \"num2 = \" + ( ' ' * bnum1.length ) + num2.to_s(2)\n puts \"b|& = \" + ( ' ' * ([bnum1.length, bnum2.length].min ) + band)\nend",
"def bit_xor(x, bits)\n bits.map{|b| x[b]}.reduce(:^)\n end",
"def op_xor(t_sym, f_sym, num)\n chars = num.split('')\n num_of_trues = 0\n chars.each do |c|\n if c == \"1\"\n num_of_trues += 1\n end\n end\n\n if num_of_trues.to_i.even?\n return f_sym\n else\n return t_sym\n end\nend",
"def MUX2X1(x,y) XOR(x,y); end",
"def xor?(one, two)\n if one && two\n false\n elsif one || two\n true\n else\n false\n end\nend",
"def bit_xor\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 52 )\n return_value = BitXorReturnValue.new\n\n # $rule.start = the first token seen before matching\n return_value.start = @input.look\n\n root_0 = nil\n char_literal238 = nil\n bit_and237 = nil\n bit_and239 = nil\n\n tree_for_char_literal238 = nil\n\n begin\n root_0 = @adaptor.create_flat_list\n\n\n # at line 593:5: bit_and ( '^' bit_and )*\n @state.following.push( TOKENS_FOLLOWING_bit_and_IN_bit_xor_3918 )\n bit_and237 = bit_and\n @state.following.pop\n if @state.backtracking == 0\n @adaptor.add_child( root_0, bit_and237.tree )\n end\n # at line 593:13: ( '^' bit_and )*\n while true # decision 55\n alt_55 = 2\n look_55_0 = @input.peek( 1 )\n\n if ( look_55_0 == HAT )\n alt_55 = 1\n\n end\n case alt_55\n when 1\n # at line 593:16: '^' bit_and\n char_literal238 = match( HAT, TOKENS_FOLLOWING_HAT_IN_bit_xor_3923 )\n if @state.backtracking == 0\n\n tree_for_char_literal238 = @adaptor.create_with_payload( char_literal238 )\n root_0 = @adaptor.become_root( tree_for_char_literal238, root_0 )\n\n end\n @state.following.push( TOKENS_FOLLOWING_bit_and_IN_bit_xor_3927 )\n bit_and239 = bit_and\n @state.following.pop\n if @state.backtracking == 0\n @adaptor.add_child( root_0, bit_and239.tree )\n end\n\n else\n break # out of loop for decision 55\n end\n end # loop for decision 55\n # - - - - - - - rule clean up - - - - - - - -\n return_value.stop = @input.look( -1 )\n\n if @state.backtracking == 0\n\n return_value.tree = @adaptor.rule_post_processing( root_0 )\n @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )\n\n end\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 52 )\n\n end\n \n return return_value\n end",
"def xor?(num1, num2)\n (num1 && num2) || (!num2 && !num1) ? false : true\nend",
"def xor(other)\n @bits ^ bits_from_object(other)\n end",
"def xor_h\n end",
"def xor?(x, y)\n (x || !y) || (y && !x)\nend",
"def xor?(one, two)\n return true if one && !two\n return true if two && !one\n\n false\nend",
"def xor?(one, two)\n (one && !two) || (two && !one)\nend",
"def xor?(arg1, arg2)\r\n\r\nend",
"def xor?(a,b)\n if a && !b\n true\n elsif !a && b\n true\n else\n false\n end\nend",
"def xor(*args)\n args.inject(self, :^)\n end",
"def xor?(input1, input2)\n if input1 && input2\n false\n elsif \n input1 || input2\n true\n else \n false\n end \nend",
"def xor(left, right)\n res = Array.new\n 0.upto(3) do |i|\n temp = left[i] ^ right[i]\n res << temp\n end\n res\n end",
"def xor_n\n value = next_byte\n xor_to_a value\n @clock += 2\n end",
"def xor?(x, y)\n return true if x && !y\n return true if y && !x\n false\nend",
"def xor?(x, y)\n return true if x && !y\n return true if y && !x\n false\nend",
"def xor?(value1, value2)\n (value1 && !value2) || (value2 && !value1)\nend",
"def xor?(value1, value2)\n (value1 && !value2) || (value2 && !value1)\nend",
"def xor?(op_1, op_2)\n (op_1 == true && op_2 == false) || (op_1 == false && op_2 == true) \nend",
"def xor(a,b)\n if (a == true && b == true) || (a == false && b == false)\n return false\n else\n return true\n end\nend",
"def xor?(one, two)\n if ((one == true) && (two == false))\n true\n elsif ((one == false) && (two == true))\n true\n else\n false\n end\nend",
"def xor?(arg1, arg2)\n if arg1 && !arg2\n true\n elsif !arg1 && arg2\n true\n else \n false\n end\nend",
"def xor?(x, y)\n (x && !y) || (!x && y)\nend",
"def fixedXOR(a = 0x1c0111001f010100061a024b53535009181c, b = 0x686974207468652062756c6c277320657965)\n if a.to_s(16).length == b.to_s(16).length\n res = a ^ b\n else\n # TODO: raise error\n res = 0\n puts \"error: diff size arguments\"\n end\n res\nend",
"def xor_missing_element array1, array2\n return nil if array1.length == 0 && array2.length == 0\n result = 0\n (array1 + array2).each do |number|\n result ^= number\n end\n return result\nend",
"def xor?(value1, value2)\n return true if value1 && !value2\n return true if value2 && !value1\n\n false\nend",
"def execute_XOR(destination, source)\n\t\t# all flags are affected except AF is undefined\n\t\tdestination.value ^= source.value\n\t\tset_logical_flags_from destination.value, destination.size\n\tend",
"def xor?(num1, num2)\n\n # If num1 is true and num2 is false, we're still going to return true\n return true if num1 && !num2\n # If num2 is true and num1 is false, we're still going to return true\n return true if num2 && !num1\nend",
"def xor?(arg1, arg2)\r\n (arg1 && !arg2) || (arg2 && !arg1)\r\nend",
"def xor?(value1, value2)\n return true if value1 && !value2\n return true if value2 && !value1\n false\nend",
"def xor2?(arg1, arg2)\n (arg1 && !arg2) || (!arg1 && arg2)\nend",
"def ^(p0) end",
"def ^(p0) end",
"def ^(p0) end",
"def ^(p0) end",
"def ^(p0) end",
"def xor?(op1, op2)\n (op1 || op2) && !(op1 && op2)\nend",
"def xor?(arg1, arg2)\n if arg1 && !arg2 || !arg1 && arg2\n true\n else\n false\n end\nend",
"def xor?(this, that)\n (!this && that) || (this && !that)\nend",
"def xor?(first, second)\n (first && !second) || (!first && second)\nend",
"def xor?(parameter1, parameter2)\r\n return true if parameter1 == true && parameter2 == false\r\n return true if parameter1 == false && parameter2 == true\r\n return false if parameter1 == false && parameter2 == false\r\n return false if parameter1 == true && parameter2 == true\r\nend",
"def xor?(arg1, arg2)\n if arg1\n if arg2\n false\n else\n true\n end\n else\nif arg2\n true\n else\n false\n end\n end\nend",
"def xor?(arg1, arg2)\n (arg1 && !arg2) || (arg2 && !arg1) ? true : false\nend",
"def xor(*others)\n self.class.xor(self, *others)\n end",
"def xor?(arg1, arg2)\n if arg1 && arg2\n false\n elsif !arg1 && !arg2\n false\n else \n true\n end\nend",
"def xor_hl\n end",
"def xor(first, second)\n first.bytes.zip(second.bytes).map{ |(a,b)| (a ^ b).chr }.join('')\n end",
"def xor?(arg1, arg2)\n return true if arg1 && !arg2\n return true if arg2 && !arg1\n false # necessary because previous line returns nil (not false) if condition falsey\nend",
"def xor?(arg1, arg2)\n if arg1 && !arg2 ||\n !arg1 && arg2\n return true\n else\n return false\n end\nend",
"def test_xor\n assert_false F ^ F, 'F ^ F'\n assert_maybe F ^ M, 'F ^ M'\n assert_true F ^ T, 'F ^ T'\n\n assert_maybe M ^ F, 'M ^ F'\n assert_maybe M ^ M, 'M ^ M'\n assert_maybe M ^ T, 'M ^ T'\n\n assert_true T ^ F, 'T ^ F'\n assert_maybe T ^ M, 'T ^ M'\n assert_false T ^ T, 'T ^ T'\n end",
"def mask(a, b)\n a ^ b\n end",
"def ^(value)\n value = _arg2int(value)\n value &= self.mask if (bounded?)\n bs = dup\n bs.from_i(value ^ bs.to_i)\n bs\n end",
"def xor?(value1, value2)\n !!((value1 && !value2) || (value2 && !value1))\nend",
"def exclusive_or (p,q)\n p ^ q\nend",
"def xor?(value1, value2)\n (value1 || value2) && !(value1 && value2)\nend",
"def bit_or\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 51 )\n return_value = BitOrReturnValue.new\n\n # $rule.start = the first token seen before matching\n return_value.start = @input.look\n\n root_0 = nil\n char_literal235 = nil\n bit_xor234 = nil\n bit_xor236 = nil\n\n tree_for_char_literal235 = nil\n\n begin\n root_0 = @adaptor.create_flat_list\n\n\n # at line 589:5: bit_xor ( '|' bit_xor )*\n @state.following.push( TOKENS_FOLLOWING_bit_xor_IN_bit_or_3894 )\n bit_xor234 = bit_xor\n @state.following.pop\n if @state.backtracking == 0\n @adaptor.add_child( root_0, bit_xor234.tree )\n end\n # at line 589:13: ( '|' bit_xor )*\n while true # decision 54\n alt_54 = 2\n alt_54 = @dfa54.predict( @input )\n case alt_54\n when 1\n # at line 589:15: '|' bit_xor\n char_literal235 = match( PIPE, TOKENS_FOLLOWING_PIPE_IN_bit_or_3898 )\n if @state.backtracking == 0\n\n tree_for_char_literal235 = @adaptor.create_with_payload( char_literal235 )\n root_0 = @adaptor.become_root( tree_for_char_literal235, root_0 )\n\n end\n @state.following.push( TOKENS_FOLLOWING_bit_xor_IN_bit_or_3902 )\n bit_xor236 = bit_xor\n @state.following.pop\n if @state.backtracking == 0\n @adaptor.add_child( root_0, bit_xor236.tree )\n end\n\n else\n break # out of loop for decision 54\n end\n end # loop for decision 54\n # - - - - - - - rule clean up - - - - - - - -\n return_value.stop = @input.look( -1 )\n\n if @state.backtracking == 0\n\n return_value.tree = @adaptor.rule_post_processing( root_0 )\n @adaptor.set_token_boundaries( return_value.tree, return_value.start, return_value.stop )\n\n end\n rescue ANTLR3::Error::RecognitionError => re\n report_error(re)\n recover(re)\n return_value.tree = @adaptor.create_error_node( @input, return_value.start, @input.look(-1), re )\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 51 )\n\n end\n \n return return_value\n end",
"def ^(n)\n base = n>0 ? self : !self\n res = Permutation::IDENTITY\n (n.abs).times {res*=base}\n res\n end",
"def xor?(a, b)\n return true if a && !b\n return true if !a && b\n false\nend",
"def xor?(argument_1, argument_2)\n if argument_1\n if argument_2 == false\n return true\n else\n return false\n end\n elsif argument_2\n if argument_1 == false\n return true\n else \n return false\n end\n else\n return false\n end\nend",
"def solution(n)\n n & 15\nend",
"def bitnot(b)\n (~b)&1\nend",
"def xor?(arg1, arg2)\n if !!arg1 == !!arg2\n false\n else\n true\n end \nend",
"def xor (keynum, pt, key)\n # get the individual key from the key schedule\n k = key[keynum,4]\n if $decrypt\n # reverse the reversed key to correct it\n k = k.reverse\n # run the key through the permputation if we are in the correct step\n if $permute\n k = permute(k, $perm)\n end\n end\n # xor the key and hex\n ret = k.hex ^ pt.hex\n # turn the number back into hex\n ret = ret.to_s(16)\n # pad the number with leading 0's\n while (ret.length < 4)\n ret.prepend(\"0\")\n end\n return ret\nend",
"def xor?(value1, value2)\r\n !!((value1 && !value2) || (value2 && !value1)) # !! forces the return to be a boolean\r\nend",
"def XOR(str1,str2)\n ret =\"\"\n str1.split(//).each_with_index do |c, i|\n ret[i] = (str1[i].ord ^ str2[i].ord).chr\n end\n return ret\nend",
"def ^ other\n (self.to_s ^ other).to_sym\n end",
"def OF_CHECKING(a,b,sum) \n\tAND(XOR(sum,a),NOT(XOR(a,b)))\nend",
"def xor\n x, y = stack.pop(2)\n push x ^ y\n end",
"def x_xor_y\n x = @x.content\n y = @y.content\n z = Array.new @z.length, 0\n\n @z.length.times { |i| z[i] = x[i] ^ y[i] }\n\n @z.content = z\n end",
"def find_complement(num)\n result = 0\n\n num_bits = num.to_s(2).chars.map(&:to_i) # Convert to binary (base 2) and map to integers\n\n num_bits.reverse.each_with_index do |n, idx|\n n = n == 0 ? 1 : 0\n result += 2 ** idx * (n) # Convert to base 10\n end\n\n result\nend",
"def solution(a)\n # write your code in Ruby 2.2\n \n return 0 if a.empty?\n \n # decode\n bits = []\n a.each_with_index do |bit, i|\n bits << bit*((-2)**i)\n end\n \n changed_bits = bits.map { |el| -el }\n answer = []\n changed_bits.each_with_index do |changed_bit, i|\n answer\n end\n # number = bits.inject(:+)\n \n # change number\n # number = -number\n \n # encode\n \n end",
"def xor?(a, b)\n if (a == true && b == false) || (a == false && b == true)\n true\n end\nend",
"def xor?(first_arg, second_arg)\n return true if first_arg == false && second_arg == true\n return true if first_arg == true && second_arg == false\nend",
"def xor?(bool_1, bool_2)\n bool_1 == bool_2 ? false : bool_1 || bool_2\nend",
"def ^(pow)\r\n\t\tpower(pow)\r\n\tend",
"def odd_duplicates(array)\n xor = array.reduce(0, :^)\nend",
"def xor?(condition1, condition2)\n condition1 ? !condition2 : !!condition2\nend",
"def crack_xor\n key_size = (2..40).to_a\n data = Tools.get_data6\n binding.pry\n \n end",
"def xor?(input1, input2)\n if input1 == true && input2 == false # => false, true, false, false\n true # => true\n elsif input1 == false && input2 == true # => true, false, false\n true # => true\n else\n false # => false, false\n end # => true, true, false, false\nend",
"def evenNumber(number)\n # AND the last bit, resultant are \n # Odd is 1 and even is 0\n # Then XOR the result so that it returns 1 for even and 0 for odd\n return (number & 1) ^ 1 \nend",
"def xor?(expression1, expression2)\n if expression1 == true && expression2 == true\n false\n elsif expression1 == false && expression2 == false\n false\n else\n true\n end\nend",
"def complement(bit)\n bit.succ % 2\n end",
"def xor?(condition1, condition2)\n if condition1 \n return true if !condition2\n elsif condition2\n return true if !condition1\n end\n false\nend",
"def calculate_doublepulsar_xor_key(s)\n x = (2 * s ^ (((s & 0xff00 | (s << 16)) << 8) | (((s >> 16) | s & 0xff0000) >> 8)))\n x & 0xffffffff # this line was added just to truncate to 32 bits\n end"
] | [
"0.7760825",
"0.7709126",
"0.7590266",
"0.75561017",
"0.750193",
"0.74455273",
"0.7440278",
"0.74336374",
"0.7238307",
"0.72370285",
"0.70961106",
"0.70602673",
"0.7036923",
"0.7026291",
"0.70116496",
"0.7010116",
"0.6998041",
"0.69966793",
"0.6978643",
"0.69718885",
"0.696093",
"0.693028",
"0.6921062",
"0.6917477",
"0.68983537",
"0.68939006",
"0.6880052",
"0.6849514",
"0.684392",
"0.68377745",
"0.6782976",
"0.677629",
"0.677629",
"0.67431945",
"0.67431945",
"0.67413276",
"0.67301035",
"0.6726734",
"0.67266065",
"0.67215437",
"0.6698006",
"0.66858786",
"0.66786957",
"0.6675536",
"0.66707796",
"0.66648954",
"0.6663054",
"0.6640968",
"0.66155577",
"0.66155577",
"0.66155577",
"0.66155577",
"0.66155577",
"0.6599101",
"0.6597086",
"0.65926135",
"0.6590543",
"0.6587598",
"0.6581728",
"0.65814245",
"0.65810907",
"0.6578643",
"0.6571371",
"0.6564894",
"0.65644866",
"0.6558975",
"0.65585655",
"0.6553596",
"0.6536651",
"0.65355265",
"0.6523697",
"0.65099883",
"0.65048844",
"0.646588",
"0.6460932",
"0.64533246",
"0.6448248",
"0.6437477",
"0.6416305",
"0.64123464",
"0.6411731",
"0.6404787",
"0.63897985",
"0.6383731",
"0.63718146",
"0.637126",
"0.63696545",
"0.6365197",
"0.6358908",
"0.6358819",
"0.6356307",
"0.63526875",
"0.6351686",
"0.6339465",
"0.6330559",
"0.63271743",
"0.63268185",
"0.63262755",
"0.63220143",
"0.63074064",
"0.63048977"
] | 0.0 | -1 |
GET /accounting_actions GET /accounting_actions.json | def index
@q = AccountingAction.ransack(params[:q])
@accounting_actions = @q.result(distinct: true)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @accounting_entries = AccountingEntry.all\n\n authorize AccountingEntry\n end",
"def actions\n return @actions if @actions\n @actions = Client.get(\"/organizations/#{id}/actions\").json_into(Action)\n end",
"def index\n @wallet_actions = WalletAction.all\n end",
"def set_accounting_action\n @accounting_action = AccountingAction.find(params[:id])\n end",
"def index\n @borrow_requests = current_user.borrow_requests.actionable\n @pending_approvals = current_user.approvals.where(\"status = 'pending'\")\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @borrow_requests }\n end\n end",
"def actions\n %w[credit]\n end",
"def list\n List.from_response client.get(\"/actions/#{action_id}/list\")\n end",
"def index\n @tredit_actions = TreditAction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @tredit_actions }\n end\n end",
"def index\n\t\tstore_location\n\n @pending_commissions \t= PayableAction.pending\n\t\t@approved_commissions = PayableAction.approved\n\t\t@paid_commissions \t\t= PayableAction.paid\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payable_actions }\n end\n end",
"def index\n @user_actions = UserAction.all\n render json: @user_actions\n end",
"def creditCardIndex\n render json: Approved.allCreditCard\n end",
"def actions\n client.actions\n end",
"def index\n @actual_action_plans = ActualActionPlan.all\n end",
"def index\r\n @aes_actions = Action.all\r\n end",
"def dashboard\n actions = %w(create update destroy)\n @company = current_company\n @recordings = current_company.action_recordings.where(:action => actions).limit(50)\n end",
"def credit\n handle_response(get(\"/credit.json\"))\n end",
"def index\n @buy_actions = BuyAction.all\n end",
"def index\n @_resources = client.credit_contracts.includes(:main_account, :current_account, credit: %i[currency credit_type])\n render layout: 'application_fluid'\n end",
"def index\n @marketing_actions = MarketingAction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @marketing_actions }\n end\n end",
"def index\n @acct_transactions = AcctTransaction.all\n end",
"def index\n @resources = Resource.where(\"is_approved = true\")\n render json: @resources, status: 200\n end",
"def index\n @accountables = Accountable.all\n end",
"def index\n\t\t@accounts = Account.all\n\t\trespond_to do |format|\n\t\t\tformat.json { render json: @accounts }\n\t\tend\n\tend",
"def index\n @accounts = policy_scope(Account)\n\n render json: @accounts, include: [:user]\n end",
"def index\n authorize @thing, :get_inquiry?\n @thing_inquiries = @thing.inquiry\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n respond_with(accounts)\n end",
"def index\n @my_actions = MyAction.all\n end",
"def index\n @accreditations = Accreditation.all\n end",
"def index\n @alarm_actions = AlarmAction.all\n end",
"def index\n @acquisitions = Acquisition.all\n end",
"def index\n @accounting_items = Accounting::Item\n .where(user_id: @current_user.id)\n .includes(:type)\n .joins(:type)\n\n respond_to do |format|\n format.json { render json: @accounting_items, include: :type }\n end\n end",
"def show\n authorize @accounts\n render json: @account\n end",
"def index\n @automated_transactions = current_airport.automated_transactions\n end",
"def index_approvable\n @asset_categorizations = AssetCategorization.accessible_by(current_ability, :approve).search(params[:search]).order(\"approved, confirmed, number_arranged, submitted, id desc\").page(params[:page])\n\n respond_to do |format|\n format.html \n format.json { render json: @asset_categorizations }\n format.xml { render xml: @asset_categorizations }\n end\n end",
"def index\n @accounts = current_user.accounts\n @wallet = current_user.wallet\n authorize @accounts\n end",
"def actions\n return @actions if @actions\n @actions = Client.get(\"/boards/#{id}/actions\").json_into(Action)\n end",
"def credit\n handle_response(self.class.get(\"/credit.json\"))\n end",
"def index_confirmable\n @asset_info_adjustments = AssetInfoAdjustment.accessible_by(current_ability, :confirm).search(params[:search]).page(params[:page])\n\n respond_to do |format|\n format.html { render \"index\" }\n format.json { render json: @asset_info_adjustments }\n format.xml { render xml: @asset_info_adjustments }\n end\n end",
"def index\n @actionables = Actionable.all\n end",
"def available_actions\n ret = {}\n @jira.available_actions(self[:key]).each{|q| ret[q['id']] = q['name']}\n ret\n end",
"def index\n get_contracts\n end",
"def create\n @accounting_action = AccountingAction.new(accounting_action_params)\n\n respond_to do |format|\n if @accounting_action.save\n format.html { redirect_to @accounting_action, notice: 'Ação foi criada com sucesso.' }\n format.json { render :show, status: :created, location: @accounting_action }\n else\n format.html { render :new }\n format.json { render json: @accounting_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @due_actions = DueAction.all\n end",
"def index_approvable\n @asset_info_adjustments = AssetInfoAdjustment.accessible_by(current_ability, :approve).search(params[:search]).page(params[:page])\n\n respond_to do |format|\n format.html { render \"index\" }\n format.json { render json: @asset_info_adjustments }\n format.xml { render xml: @asset_info_adjustments }\n end\n end",
"def index\n @inciting_incidents = IncitingIncident.all\n render json: @inciting_incidents\n end",
"def index\n @accounting = Accounting.find(params[:accounting_id])\n @shares = @accounting.shares\n end",
"def task_actions(task_name)\n get \"#{base_url}/tasks/#{task_name}/actions\"\n end",
"def index\n @accounting_reports = AccountingReport.all\n end",
"def index\n if @account\n @transactions = @account.transactions\n else\n @transactions = Transaction.all\n end\n render json: @transactions\n end",
"def index_confirmable\n @asset_categorizations = AssetCategorization.accessible_by(current_ability, :confirm).search(params[:search]).order(\"approved, confirmed, number_arranged, submitted, id desc\").page(params[:page])\n\n respond_to do |format|\n format.html \n format.json { render json: @asset_categorizations }\n format.xml { render xml: @asset_categorizations }\n end\n end",
"def index\n @accounts = Account.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @accounts }\n end\n end",
"def index\n @onboardings = Onboarding.all\n render json: @onboardings.as_json(:only => [:id, :company_name, :company_uen, :a_corpsecretary, :a_accounting, :a_status, :a_action, :a_date_fye, :a_date_agm, :a_date_renewal, :created_at])\n\n end",
"def index\n @withdrawal_requests = WithdrawalRequest.all\n end",
"def index\n @contracts = Contract.all\n authorize @contracts\n end",
"def index\n @account = Account.find(params[:account_id])\n @journals = @account.journals\n end",
"def index\n\n begin\n\n @accounts = Account.active\n render json: @accounts.to_json(:except=>:password, :methods => [:subdomains, :template] )\n\n rescue => e\n render :json => e.message, :status => :unprocessable_entity\n end\n\n end",
"def index\n @ticket_actions = TicketAction.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @ticket_actions }\n end\n end",
"def actions\n @actions\n end",
"def available_actions\n [\n Action::BuyCertificate,\n Action::Pass,\n Action::SellCertificates,\n Action::StartCompany\n ]\n end",
"def actions(rental)\n tot_com = price(rental) * 30 / 100\n start_date = DateTime.parse(rental[\"start_date\"])\n end_date = DateTime.parse(rental[\"end_date\"])\n duration = (end_date - start_date).to_i + 1\n insurance_fee = tot_com / 2 .to_i\n assistance_fee = duration * 100\n drivy_fee = tot_com - insurance_fee - assistance_fee\n\n debit_driver = {\"who\": \"driver\", \"type\": \"debit\", \"amount\": price(rental)}\n credit_owner = {\"who\": \"owner\", \"type\": \"credit\", \"amount\": (price(rental) - tot_com)}\n credit_insurance = {\"who\": \"insurance\", \"type\": \"credit\", \"amount\": insurance_fee}\n credit_assistance = {\"who\": \"assistance\", \"type\": \"credit\", \"amount\": assistance_fee}\n credit_drivy = {\"who\": \"drivy\", \"type\": \"credit\", \"amount\": drivy_fee}\n\n actions = [debit_driver, credit_owner, credit_insurance, credit_assistance, credit_drivy]\nend",
"def authorizations\n @@authorized_actions ||= {}\n @@authorized_actions\n end",
"def index\n @accountants = Accountant.all\n end",
"def index\n\n @debtors = Debtor.all\n\n render json: @debtors\n end",
"def index\n @grants =\n if @company\n @company.grants(params[:filter_by], params[:sort_by], params[:desc])\n else\n Grant.kept.order(name: :asc)\n end\n\n headers[\"Total\"] = @grants.count\n headers[\"Per-Page\"] = params[:per_page]\n\n render json: (params[:page] == 'all' ? @grants : paginator(@grants)), has_type: false\n end",
"def accounting_action_params\n params.require(:accounting_action).permit(:codigo, :descricao, :exercise_id)\n end",
"def action_list(action_id, fields = \"all\")\n action_resource action_id, \"list\", fields: fields\n end",
"def get_transactions_list(targacct, action_set, page, per_page)\n # Set up the :conditons query \n query = \"target_account_id = ?\"\n args = [targacct]\n # If we have and action set add the actions.\n if (!action_set.nil? && !action_set.empty?)\n as = AcctActionSet.find(action_set)\n if as\n\tactions = as.actions\n\tquery << \" AND (acct_action_id = ? \"\n\targs << actions.first\n\tactions.shift\n\tfor act in actions\n\t query << \"OR acct_action_id = ? \"\n\t args << act\n\tend\n query << \")\"\n end\n end\n conditions = [query] + args\n p conditions\n AcctTransaction.paginate(\n :page => page,\n :per_page => per_page,\n :conditions => conditions,\n :order => \"date DESC, id DESC\")\n end",
"def index\n @city_actions = CalendarAction.city_actions\n @people_actions = CalendarAction.people_actions\n end",
"def get_actions\n get_document.get_actions_yaml\n end",
"def index\n @action_names = ActionName.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @action_names }\n end\n end",
"def index\n @kactions = Kaction.all\n end",
"def show\n authorize AccountingEntry\n end",
"def index\n @schedule_actions = ScheduleAction.all\n end",
"def index\n @investigations = Investigation.where(:visible => true)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @investigations }\n end\n end",
"def index\n @admittings = Admitting.all\n render json: @admittings\n end",
"def index\n @accounts = current_user.person.blackberry_accounts\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @accounts }\n end\n end",
"def index\n @ncco_record_actions = NccoRecordAction.all\n end",
"def index\n @call_to_actions = CallToAction.all\n end",
"def index\n @goals = current_user.goals.where(archived: false)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @goals }\n end\n end",
"def event_actions(options = {})\n make_json_api_request :get, \"v2/#{account_id}/event_actions\", options\n end",
"def index\n @unit_actions = UnitAction.all\n end",
"def index\n @admin_credits = Credit.all\n end",
"def index\n @achievements = Achievement.all\n respond_with @achievements\n end",
"def index\n #@accounts = Account.all\n redirect_to root_path\n #respond_to do |format|\n #format.html # index.html.erb\n #format.json { render json: @accounts }\n #end\n end",
"def index\n getProfile\n @availabilities = @therapist.get_availabilities\n @rec_Availabilities = @therapist.get_recuring_availabilities(2000,1)\n respond_to do |format|\n format.html { redirect_to availabitity_index, notice: \"Appointment declined.\"}\n format.json { render :status => 200, :json => { action: :index,\n availabilities: @availabilities,\n rec_availabilities: @rec_Availabilities,\n user: @user, therapist: @therapist}}\n end\n end",
"def index\n @activity_award_cfgs = ActivityAwardCfg.all\n end",
"def actions() ; info[:actions] ; end",
"def actions() ; info[:actions] ; end",
"def awaiting\n @accounts = current_user.agent_profile.get_awaiting_access_accounts\n\n respond_to do |format|\n format.html\n end\n end",
"def index\n account = Account.find(params[:account_id].to_i)\n @transactions = account.transactions\n\n transactions_json = TransactionSerializer.new(@transactions).serialized_json\n render json: transactions_json\n end",
"def index\n @pend_crates = Overview.get_pending_crates \n @paid_crates = Overview.get_last_paid_crates \n\n respond_to do |format|\n format.html # index.html.erb\n #format.json { render :json => @crates }\n end\n end",
"def index\n @dosha_actions = DoshaAction.all\n end",
"def index\n @accounts = Account.all\n end",
"def index\n @accounts = Account.all\n end",
"def index\n @accounts = Account.all\n end",
"def index\n @accounts = Account.all\n end",
"def index\n @accounts = Account.all\n end",
"def index\n @accounts = Account.all\n end"
] | [
"0.6761725",
"0.660253",
"0.65338796",
"0.6523973",
"0.6495803",
"0.63214195",
"0.6217173",
"0.61983156",
"0.612494",
"0.6096261",
"0.60802764",
"0.60781306",
"0.60246146",
"0.5999102",
"0.59821355",
"0.59202373",
"0.5909086",
"0.59068245",
"0.58836776",
"0.58461237",
"0.5804248",
"0.57936287",
"0.57897013",
"0.5779305",
"0.5765123",
"0.5762038",
"0.5762038",
"0.57602406",
"0.5760145",
"0.5758875",
"0.57548296",
"0.57488006",
"0.57365507",
"0.5730272",
"0.5718031",
"0.5716657",
"0.57161295",
"0.57003623",
"0.5691273",
"0.56870997",
"0.5686917",
"0.5682042",
"0.567038",
"0.566872",
"0.56645745",
"0.56622005",
"0.5660925",
"0.56596696",
"0.5653365",
"0.56524783",
"0.5652072",
"0.5642012",
"0.56372225",
"0.5632938",
"0.5625235",
"0.562031",
"0.5618694",
"0.56166935",
"0.5601022",
"0.5591333",
"0.55852574",
"0.5581184",
"0.5578226",
"0.5566467",
"0.5564307",
"0.55634683",
"0.5550803",
"0.5550082",
"0.5546911",
"0.5543846",
"0.55437714",
"0.5543303",
"0.55373466",
"0.5534813",
"0.5533706",
"0.55271",
"0.5522882",
"0.55161035",
"0.55148965",
"0.5506784",
"0.5504517",
"0.55025494",
"0.5496673",
"0.5496269",
"0.54937714",
"0.5491554",
"0.5480595",
"0.5478304",
"0.5478011",
"0.5478011",
"0.54734975",
"0.5472887",
"0.5471642",
"0.54689956",
"0.54669887",
"0.54669887",
"0.54669887",
"0.54669887",
"0.54669887",
"0.54669887"
] | 0.70398366 | 0 |
GET /accounting_actions/1 GET /accounting_actions/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @q = AccountingAction.ransack(params[:q])\n @accounting_actions = @q.result(distinct: true)\n end",
"def set_accounting_action\n @accounting_action = AccountingAction.find(params[:id])\n end",
"def index\n @accounting_entries = AccountingEntry.all\n\n authorize AccountingEntry\n end",
"def index\n @borrow_requests = current_user.borrow_requests.actionable\n @pending_approvals = current_user.approvals.where(\"status = 'pending'\")\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @borrow_requests }\n end\n end",
"def index\n @wallet_actions = WalletAction.all\n end",
"def actions\n return @actions if @actions\n @actions = Client.get(\"/organizations/#{id}/actions\").json_into(Action)\n end",
"def index\n @tredit_actions = TreditAction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @tredit_actions }\n end\n end",
"def creditCardIndex\n render json: Approved.allCreditCard\n end",
"def actions\n %w[credit]\n end",
"def list\n List.from_response client.get(\"/actions/#{action_id}/list\")\n end",
"def index\n @user_actions = UserAction.all\n render json: @user_actions\n end",
"def index\n @actual_action_plans = ActualActionPlan.all\n end",
"def credit\n handle_response(get(\"/credit.json\"))\n end",
"def index\n\t\tstore_location\n\n @pending_commissions \t= PayableAction.pending\n\t\t@approved_commissions = PayableAction.approved\n\t\t@paid_commissions \t\t= PayableAction.paid\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payable_actions }\n end\n end",
"def actions\n client.actions\n end",
"def show\n @tredit_action = TreditAction.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @tredit_action }\n end\n end",
"def show\n @tredit_action = TreditAction.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @tredit_action }\n end\n end",
"def create\n @accounting_action = AccountingAction.new(accounting_action_params)\n\n respond_to do |format|\n if @accounting_action.save\n format.html { redirect_to @accounting_action, notice: 'Ação foi criada com sucesso.' }\n format.json { render :show, status: :created, location: @accounting_action }\n else\n format.html { render :new }\n format.json { render json: @accounting_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @_resources = client.credit_contracts.includes(:main_account, :current_account, credit: %i[currency credit_type])\n render layout: 'application_fluid'\n end",
"def index\n @resources = Resource.where(\"is_approved = true\")\n render json: @resources, status: 200\n end",
"def credit\n handle_response(self.class.get(\"/credit.json\"))\n end",
"def index\n @buy_actions = BuyAction.all\n end",
"def index\n @accounting_items = Accounting::Item\n .where(user_id: @current_user.id)\n .includes(:type)\n .joins(:type)\n\n respond_to do |format|\n format.json { render json: @accounting_items, include: :type }\n end\n end",
"def dashboard\n actions = %w(create update destroy)\n @company = current_company\n @recordings = current_company.action_recordings.where(:action => actions).limit(50)\n end",
"def index\r\n @aes_actions = Action.all\r\n end",
"def index\n @marketing_actions = MarketingAction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @marketing_actions }\n end\n end",
"def index\n @my_actions = MyAction.all\n end",
"def show\n authorize @accounts\n render json: @account\n end",
"def index\n @accounting = Accounting.find(params[:accounting_id])\n @shares = @accounting.shares\n end",
"def index\n @alarm_actions = AlarmAction.all\n end",
"def show\n head :forbidden\n\n # @action = Action.find(params[:id])\n\n # render json: @action\n end",
"def index_approvable\n @asset_categorizations = AssetCategorization.accessible_by(current_ability, :approve).search(params[:search]).order(\"approved, confirmed, number_arranged, submitted, id desc\").page(params[:page])\n\n respond_to do |format|\n format.html \n format.json { render json: @asset_categorizations }\n format.xml { render xml: @asset_categorizations }\n end\n end",
"def index\n @accreditations = Accreditation.all\n end",
"def index\n authorize @thing, :get_inquiry?\n @thing_inquiries = @thing.inquiry\n end",
"def index\n @acct_transactions = AcctTransaction.all\n end",
"def index_confirmable\n @asset_info_adjustments = AssetInfoAdjustment.accessible_by(current_ability, :confirm).search(params[:search]).page(params[:page])\n\n respond_to do |format|\n format.html { render \"index\" }\n format.json { render json: @asset_info_adjustments }\n format.xml { render xml: @asset_info_adjustments }\n end\n end",
"def index_approvable\n @asset_info_adjustments = AssetInfoAdjustment.accessible_by(current_ability, :approve).search(params[:search]).page(params[:page])\n\n respond_to do |format|\n format.html { render \"index\" }\n format.json { render json: @asset_info_adjustments }\n format.xml { render xml: @asset_info_adjustments }\n end\n end",
"def index\n get_contracts\n end",
"def index\n @due_actions = DueAction.all\n end",
"def index\n @onboardings = Onboarding.all\n render json: @onboardings.as_json(:only => [:id, :company_name, :company_uen, :a_corpsecretary, :a_accounting, :a_status, :a_action, :a_date_fye, :a_date_agm, :a_date_renewal, :created_at])\n\n end",
"def index_confirmable\n @asset_categorizations = AssetCategorization.accessible_by(current_ability, :confirm).search(params[:search]).order(\"approved, confirmed, number_arranged, submitted, id desc\").page(params[:page])\n\n respond_to do |format|\n format.html \n format.json { render json: @asset_categorizations }\n format.xml { render xml: @asset_categorizations }\n end\n end",
"def index\n @acquisitions = Acquisition.all\n end",
"def index\n @action_items = Actionitem.find :all\n @actions = Action.find :all\n\n session[:current_action] = params[:action_id] || 1 \n\n @action_now = Action.find(session[:current_action])\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @actionitems }\n end\n end",
"def index\n @action_names = ActionName.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @action_names }\n end\n end",
"def index\n\t\t@accounts = Account.all\n\t\trespond_to do |format|\n\t\t\tformat.json { render json: @accounts }\n\t\tend\n\tend",
"def index\n @accountables = Accountable.all\n end",
"def index\n @accounts = policy_scope(Account)\n\n render json: @accounts, include: [:user]\n end",
"def index\n @inciting_incidents = IncitingIncident.all\n render json: @inciting_incidents\n end",
"def index\n respond_with(accounts)\n end",
"def index\n #@releases = Release.all\n @releases = Release.where(cashier_id: current_user.cashier.id, view: true)\n\n # respond_to do |format|\n # format.html # index.html.erb\n # format.json { render json: @releases }\n # end\n end",
"def index\n @accounts = Account.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @accounts }\n end\n end",
"def show\n authorize AccountingEntry\n end",
"def index\n if @account\n @transactions = @account.transactions\n else\n @transactions = Transaction.all\n end\n render json: @transactions\n end",
"def actions\n return @actions if @actions\n @actions = Client.get(\"/boards/#{id}/actions\").json_into(Action)\n end",
"def index\n @budgets = Budget.find_owned_by current_user\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @budgets }\n end\n end",
"def index\n @account = Account.find(params[:account_id])\n @journals = @account.journals\n end",
"def index\n @pend_crates = Overview.get_pending_crates \n @paid_crates = Overview.get_last_paid_crates \n\n respond_to do |format|\n format.html # index.html.erb\n #format.json { render :json => @crates }\n end\n end",
"def accounting_action_params\n params.require(:accounting_action).permit(:codigo, :descricao, :exercise_id)\n end",
"def index\n @automated_transactions = current_airport.automated_transactions\n end",
"def index\n @ticket_actions = TicketAction.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @ticket_actions }\n end\n end",
"def index\n @transfers = Transfer.resources(params[:resource].capitalize)\n end",
"def action(id, type)\n res = self.class.post(\"/rest/items/#{id}/actions/#{type}/invoke\", :headers => {\"Content-Type\" => \"application/json\"}, :basic_auth => @auth)\n return res.parsed_response[\"attributes\"][0][\"value\"]\n end",
"def index\n @withdrawal_requests = WithdrawalRequest.all\n end",
"def index\n @actionables = Actionable.all\n end",
"def index\n @admin_credits = Credit.all\n end",
"def show\n @payable_action = PayableAction.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @payable_action }\n end\n end",
"def index\n @investigations = Investigation.where(:visible => true)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @investigations }\n end\n end",
"def index\n @admission_types = AdmissionType.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @admission_types }\n end\n end",
"def index\n @unit_actions = UnitAction.all\n end",
"def show\n @action_name = ActionName.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @action_name }\n end\n end",
"def index\n @accounting_reports = AccountingReport.all\n end",
"def index\n @schedule_actions = ScheduleAction.all\n end",
"def index\n @credit_types = CreditType.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @credit_types }\n end\n end",
"def index\n\n @debtors = Debtor.all\n\n render json: @debtors\n end",
"def index\n @kactions = Kaction.all\n end",
"def index\n @accounts = current_user.person.blackberry_accounts\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @accounts }\n end\n end",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def api_get(action, data)\n api_request(action, data, 'GET')\n end",
"def index\n getProfile\n @availabilities = @therapist.get_availabilities\n @rec_Availabilities = @therapist.get_recuring_availabilities(2000,1)\n respond_to do |format|\n format.html { redirect_to availabitity_index, notice: \"Appointment declined.\"}\n format.json { render :status => 200, :json => { action: :index,\n availabilities: @availabilities,\n rec_availabilities: @rec_Availabilities,\n user: @user, therapist: @therapist}}\n end\n end",
"def show\n @accessory_act = AccessoryAct.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @accessory_act }\n end\n end",
"def index\n @transfers = Transfer.all\n render json: @transfers\n end",
"def index\n @grants =\n if @company\n @company.grants(params[:filter_by], params[:sort_by], params[:desc])\n else\n Grant.kept.order(name: :asc)\n end\n\n headers[\"Total\"] = @grants.count\n headers[\"Per-Page\"] = params[:per_page]\n\n render json: (params[:page] == 'all' ? @grants : paginator(@grants)), has_type: false\n end",
"def available_actions\n ret = {}\n @jira.available_actions(self[:key]).each{|q| ret[q['id']] = q['name']}\n ret\n end",
"def action\n _action_obj.to_h\n end",
"def index\n @contracts = Contract.all\n authorize @contracts\n end",
"def index\n @accounts = current_user.accounts\n @wallet = current_user.wallet\n authorize @accounts\n end",
"def index\n account = Account.find(params[:account_id].to_i)\n @transactions = account.transactions\n\n transactions_json = TransactionSerializer.new(@transactions).serialized_json\n render json: transactions_json\n end",
"def update\n respond_to do |format|\n if @accounting_action.update(accounting_action_params)\n format.html { redirect_to @accounting_action, notice: 'Ação foi atualizada com sucesso.' }\n format.json { render :show, status: :ok, location: @accounting_action }\n else\n format.html { render :edit }\n format.json { render json: @accounting_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def show\n @bank_account_operation = BankAccountOperation.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bank_account_operation }\n end\n end",
"def index\n\n begin\n\n @accounts = Account.active\n render json: @accounts.to_json(:except=>:password, :methods => [:subdomains, :template] )\n\n rescue => e\n render :json => e.message, :status => :unprocessable_entity\n end\n\n end",
"def index\n \tif params[:for_timeline]\n\t\t\t@bills = Bill.where(:initiator_id.in => params[:politicians]).where(:complete =>true).limit(10)\n\t\telse\n\t \t@bills = Bill.all.limit(10)\n \tend\n\n respond_to do |format|\n format.json { render json: @bills.to_json(:include => {:initiator => {:only =>[:name]}}) }\n end\n\n end",
"def set_accounting\n @accounting = Accounting.find(params[:id])\n end",
"def actions() ; info[:actions] ; end",
"def actions() ; info[:actions] ; end",
"def sale_action\n @json_body['sale_action']\n end",
"def index\n @petty_cash_expenses = PettyCashExpense.all\n render json: @petty_cash_expenses\n end",
"def index\n @accountants = Accountant.all\n end",
"def get_lists_action(action)\n url = nil\n case action\n when \"new_releases\"\n url = \"#{LISTS_DETAIL_BASE_URL}/dvds/new_releases.json?apikey=#{@api_key}\"\n when \"opening\"\n url = \"#{LISTS_DETAIL_BASE_URL}/movies/opening.json?apikey=#{@api_key}\"\n when \"upcoming\"\n url = \"#{LISTS_DETAIL_BASE_URL}/movies/upcoming.json?apikey=#{@api_key}\"\n when \"in_theaters\"\n url = \"#{LISTS_DETAIL_BASE_URL}/movies/in_theaters.json?apikey=#{@api_key}\"\n when \"current_releases\"\n url = \"#{LISTS_DETAIL_BASE_URL}/dvds/current_releases.json?apikey=#{@api_key}\"\n when \"upcoming_dvds\"\n url = \"#{LISTS_DETAIL_BASE_URL}/dvds/upcoming.json?apikey=#{@api_key}\"\n when \"top_rentals\"\n url = \"#{LISTS_DETAIL_BASE_URL}/dvds/top_rentals.json?apikey=#{@api_key}\"\n else\n puts \"Not a valid action\"\n return\n end\n return get(url)\n end",
"def index\n @asset_disposals = AssetDisposal.with_permissions_to(:edit).all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @asset_disposals }\n end\n end"
] | [
"0.6820698",
"0.6751092",
"0.6464188",
"0.6462399",
"0.63931745",
"0.63807964",
"0.6253348",
"0.61621183",
"0.6077183",
"0.6070772",
"0.6046184",
"0.60236084",
"0.6017479",
"0.5997635",
"0.5943969",
"0.5914122",
"0.5914122",
"0.58570606",
"0.58531004",
"0.5845312",
"0.584212",
"0.583993",
"0.58067614",
"0.57924944",
"0.5789045",
"0.57799745",
"0.57044345",
"0.57018304",
"0.56937623",
"0.5693302",
"0.5690167",
"0.5686984",
"0.5665039",
"0.5649061",
"0.56476355",
"0.5640148",
"0.5637512",
"0.5637246",
"0.56353444",
"0.5633371",
"0.56268775",
"0.56129116",
"0.5608939",
"0.5607825",
"0.56022966",
"0.55970174",
"0.55867064",
"0.5580897",
"0.5578099",
"0.55753106",
"0.5556979",
"0.5549702",
"0.5548693",
"0.55402845",
"0.55399126",
"0.55366635",
"0.5535981",
"0.5534026",
"0.5530935",
"0.55267155",
"0.5526181",
"0.5508582",
"0.5508107",
"0.55041957",
"0.54920256",
"0.54828465",
"0.5481537",
"0.5480131",
"0.5475794",
"0.54753387",
"0.547262",
"0.546939",
"0.5467028",
"0.54662734",
"0.5466126",
"0.546124",
"0.5453944",
"0.5453944",
"0.54507023",
"0.54479617",
"0.5444708",
"0.5444615",
"0.54442763",
"0.54416305",
"0.5440102",
"0.54377484",
"0.54369044",
"0.5436381",
"0.5436299",
"0.5436299",
"0.5433993",
"0.543104",
"0.54260576",
"0.54240286",
"0.5421732",
"0.5421732",
"0.5419526",
"0.5416779",
"0.5413826",
"0.5406237",
"0.54036593"
] | 0.0 | -1 |
POST /accounting_actions POST /accounting_actions.json | def create
@accounting_action = AccountingAction.new(accounting_action_params)
respond_to do |format|
if @accounting_action.save
format.html { redirect_to @accounting_action, notice: 'Ação foi criada com sucesso.' }
format.json { render :show, status: :created, location: @accounting_action }
else
format.html { render :new }
format.json { render json: @accounting_action.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def accounting_action_params\n params.require(:accounting_action).permit(:codigo, :descricao, :exercise_id)\n end",
"def set_accounting_action\n @accounting_action = AccountingAction.find(params[:id])\n end",
"def collection_post_action(action)\n action = action.to_s.gsub('bulk_', '').to_sym\n\n raise 'expected post, patch or put http action' unless (request.post? || request.patch? || request.put?)\n raise \"expected #{resource_name} to respond to #{action}!\" if resources.to_a.present? && !resources.first.respond_to?(\"#{action}!\")\n\n successes = 0\n\n ActiveRecord::Base.transaction do\n successes = resources.select do |resource|\n begin\n resource.public_send(\"#{action}!\") if EffectiveResources.authorized?(self, action, resource)\n rescue => e\n false\n end\n end.length\n end\n\n render json: { status: 200, message: \"Successfully #{action_verb(action)} #{successes} / #{resources.length} selected #{resource_plural_name}\" }\n end",
"def index\n @q = AccountingAction.ransack(params[:q])\n @accounting_actions = @q.result(distinct: true)\n end",
"def api_post(action, data)\n api_request(action, data, 'POST')\n end",
"def post(action, **args); end",
"def create\n @accounting_entry = AccountingEntry.new(accounting_entry_params)\n\n authorize AccountingEntry\n\n respond_to do |format|\n if @accounting_entry.save\n format.html { redirect_to @accounting_entry, notice: 'Accounting entry was successfully created.' }\n format.json { render :show, status: :created, location: @accounting_entry }\n else\n format.html { render :new }\n format.json { render json: @accounting_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_accounting_using_post(accounting, opts = {})\n data, _status_code, _headers = create_accounting_using_post_with_http_info(accounting, opts)\n data\n end",
"def index\n @wallet_actions = WalletAction.all\n end",
"def create\n #@incident = @quote.incidents.new(incident_params)\n logger.info params[:incident]\n params[:incident].each do |incident|\n @incident = @quote.incidents.new(incident)\n @incident.save\n end\n respond_to do |format|\n format.json { render :json => { :code => \"201\", :description => \"Created incidents\"} }\n end\n end",
"def index\n @accounting_entries = AccountingEntry.all\n\n authorize AccountingEntry\n end",
"def actions\n %w[credit]\n end",
"def actions(rental)\n tot_com = price(rental) * 30 / 100\n start_date = DateTime.parse(rental[\"start_date\"])\n end_date = DateTime.parse(rental[\"end_date\"])\n duration = (end_date - start_date).to_i + 1\n insurance_fee = tot_com / 2 .to_i\n assistance_fee = duration * 100\n drivy_fee = tot_com - insurance_fee - assistance_fee\n\n debit_driver = {\"who\": \"driver\", \"type\": \"debit\", \"amount\": price(rental)}\n credit_owner = {\"who\": \"owner\", \"type\": \"credit\", \"amount\": (price(rental) - tot_com)}\n credit_insurance = {\"who\": \"insurance\", \"type\": \"credit\", \"amount\": insurance_fee}\n credit_assistance = {\"who\": \"assistance\", \"type\": \"credit\", \"amount\": assistance_fee}\n credit_drivy = {\"who\": \"drivy\", \"type\": \"credit\", \"amount\": drivy_fee}\n\n actions = [debit_driver, credit_owner, credit_insurance, credit_assistance, credit_drivy]\nend",
"def create_accounting_using_post_with_http_info(accounting, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: AccountingApi.create_accounting_using_post ...'\n end\n # verify the required parameter 'accounting' is set\n if @api_client.config.client_side_validation && accounting.nil?\n fail ArgumentError, \"Missing the required parameter 'accounting' when calling AccountingApi.create_accounting_using_post\"\n end\n # resource path\n local_var_path = '/accounting'\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['*/*'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = @api_client.object_to_http_body(accounting)\n auth_names = ['oauth2']\n data, status_code, headers = @api_client.call_api(:POST, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'Accounting')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: AccountingApi#create_accounting_using_post\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def create\n @wallet_action = WalletAction.new(wallet_action_params)\n\n respond_to do |format|\n if @wallet_action.save\n format.html { redirect_to @wallet_action, notice: 'Wallet action was successfully created.' }\n format.json { render :show, status: :created, location: @wallet_action }\n else\n format.html { render :new }\n format.json { render json: @wallet_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @tredit_action = TreditAction.new(params[:tredit_action])\n\n respond_to do |format|\n if @tredit_action.save\n format.html { redirect_to @tredit_action, notice: 'Tredit action was successfully created.' }\n format.json { render json: @tredit_action, status: :created, location: @tredit_action }\n else\n format.html { render action: \"new\" }\n format.json { render json: @tredit_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @buy_action = BuyAction.new(buy_action_params)\n\n respond_to do |format|\n if @buy_action.save\n format.html { redirect_to admin_path, notice: 'Buy action was successfully created.' }\n format.json { render action: 'show', status: :created, location: @buy_action }\n else\n format.html { render action: 'new' }\n format.json { render json: @buy_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_action(page_name, email, options={})\n target = \"#{self.base_url}/action/\"\n body = { page: page_name, email: email }.merge self.parse_action_options(options)\n options = {\n basic_auth: self.auth,\n body: body.to_json,\n format: :json,\n headers: {'Content-Type' => 'application/json; charset=UTF-8'}\n }\n self.class.post(target, options)\n end",
"def actions\n client.actions\n end",
"def create\n @payable_action = PayableAction.new(params[:payable_action])\n\n respond_to do |format|\n if @payable_action.save\n flash[:notice] = 'PayableAction was successfully created.'\n format.html { redirect_to([:admin, @payable_action]) }\n format.xml { render :xml => @payable_action, :status => :created, :location => @payable_action }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @payable_action.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @accounting_action.update(accounting_action_params)\n format.html { redirect_to @accounting_action, notice: 'Ação foi atualizada com sucesso.' }\n format.json { render :show, status: :ok, location: @accounting_action }\n else\n format.html { render :edit }\n format.json { render json: @accounting_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @accessory_act = AccessoryAct.new(params[:accessory_act])\n\n respond_to do |format|\n if @accessory_act.save\n format.html { redirect_to @accessory_act, :notice => 'Accessory act was successfully created.' }\n format.json { render :json => @accessory_act, :status => :created, :location => @accessory_act }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @accessory_act.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @acct_transaction = AcctTransaction.new(acct_transaction_params)\n\n respond_to do |format|\n if @acct_transaction.save\n format.html { redirect_to @acct_transaction, notice: 'Acct transaction was successfully created.' }\n format.json { render :show, status: :created, location: @acct_transaction }\n else\n format.html { render :new }\n format.json { render json: @acct_transaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n render json: ::Transaction::CreditSerializer.new( do_credit! ), status: :created\n end",
"def index\n @borrow_requests = current_user.borrow_requests.actionable\n @pending_approvals = current_user.approvals.where(\"status = 'pending'\")\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @borrow_requests }\n end\n end",
"def index\n @tredit_actions = TreditAction.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @tredit_actions }\n end\n end",
"def actions(rental)\n # Main :\n tot_com = price(rental) * 30 / 100\n start_date = DateTime.parse(rental[\"start_date\"])\n end_date = DateTime.parse(rental[\"end_date\"])\n duration = (end_date - start_date).to_i + 1\n insurance_fee = tot_com / 2 .to_i\n assistance_fee = duration * 100\n drivy_fee = tot_com - insurance_fee - assistance_fee\n\n # Options :\n gps = 0\n if options(rental).include?(\"gps\") then gps += 500 * duration end\n baby_seat = 0\n if options(rental).include?(\"baby_seat\") then baby_seat += 200 * duration end\n additional_insurance = 0\n if options(rental).include?(\"additional_insurance\") then additional_insurance += 1000 * duration end\n\n debit_driver = {\"who\": \"driver\", \"type\": \"debit\", \"amount\": price(rental) + gps + baby_seat + additional_insurance}\n credit_owner = {\"who\": \"owner\", \"type\": \"credit\", \"amount\": price(rental) - tot_com + gps + baby_seat}\n credit_insurance = {\"who\": \"insurance\", \"type\": \"credit\", \"amount\": insurance_fee}\n credit_assistance = {\"who\": \"assistance\", \"type\": \"credit\", \"amount\": assistance_fee}\n credit_drivy = {\"who\": \"drivy\", \"type\": \"credit\", \"amount\": drivy_fee + additional_insurance}\n\n actions = [debit_driver, credit_owner, credit_insurance, credit_assistance, credit_drivy]\nend",
"def cash\n # Set active_tab to use in view filters\n session[:active_tab] = \"pendings-tab\"\n\n invoice_ids = params[:client_payment][:invoices_ids].split(\",\")\n instalment_ids = params[:client_payment][:ids].split(\",\")\n amount = BigDecimal.new(params[:client_payment][:amount]) rescue 0 # 0 if error beause :amount is null and debt negative\n payment_method = params[:client_payment][:payment_method_id]\n redirect_to client_payments_path + \"#tab_pendings\", alert: I18n.t(\"ag2_gest.client_payments.generate_error_payment\") and return if payment_method.blank?\n # If these are instalments, call cash_instalments & exit\n if !instalment_ids.blank?\n cash_instalments(instalment_ids, amount, payment_method)\n return\n end\n # If these are invoices, go on from here\n client_payment = nil\n invoices = Invoice.find_all_by_id(invoice_ids).sort_by {|a| a[:created_at]}\n created_by = current_user.id if !current_user.nil?\n acu = amount\n # Receipt No.\n receipt_no = receipt_next_no(invoices.first.invoice_no[3..4]) || '0000000000'\n invoices.each do |i|\n if amount > 0\n if acu > 0\n if acu >= i.debt\n amount_paid = i.debt\n acu -= i.debt\n invoice_status = InvoiceStatus::CASH\n else\n amount_paid = acu\n acu = 0\n invoice_status = InvoiceStatus::PENDING\n end\n else\n break\n end # acu > 0\n else\n amount_paid = i.debt\n invoice_status = InvoiceStatus::CASH\n end # amount > 0\n client_payment = ClientPayment.new(receipt_no: receipt_no, payment_type: ClientPayment::CASH, bill_id: i.bill_id, invoice_id: i.id,\n payment_method_id: payment_method, client_id: i.bill.client_id, subscriber_id: i.bill.subscriber_id,\n payment_date: Time.now, confirmation_date: nil, amount: amount_paid, instalment_id: nil,\n client_bank_account_id: nil, charge_account_id: i.charge_account_id, created_by: created_by)\n if client_payment.save\n i.invoice_status_id = invoice_status\n i.save\n end\n end # invoices.each do\n redirect_to client_payments_path + \"#tab_pendings\", notice: (I18n.t('ag2_gest.client_payments.index.cash_ok') + \" #{view_context.link_to I18n.t('ag2_gest.client_payments.index.click_to_print_receipt'), payment_receipt_client_payment_path(client_payment, :format => :pdf), target: '_blank'}\").html_safe\n # redirect_to client_payments_path, notice: \"Recibo/Factura/s traspasados/as a Caja.\"\n rescue\n redirect_to client_payments_path + \"#tab_pendings\", alert: I18n.t('ag2_gest.client_payments.index.cash_error')\n end",
"def create\n @actual_action_plan = ActualActionPlan.new(actual_action_plan_params)\n\n respond_to do |format|\n if @actual_action_plan.save\n format.html { redirect_to @actual_action_plan, notice: 'Actual action plan was successfully created.' }\n format.json { render :show, status: :created, location: @actual_action_plan }\n else\n format.html { render :new }\n format.json { render json: @actual_action_plan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def action_params\n params.require(:new_action).permit(:action_type, :ship_id)\n end",
"def create\n @award = Award.new(award_params)\n respond_to do |format|\n if @award.save\n a_data = JSON.parse params[:json_string]\n a_data.each do |a|\n @item = get_new_award_item(@award, a) unless a.nil?\n end\n AwardMailer.approval_request(@award)\n if current_user.admin\n format.html { redirect_to patient_path(@award.patient), notice: 'Award was successfully created.' }\n else\n format.html { redirect_to new_patient_path, notice: 'Award was successfully created.' }\n end\n format.json { render :show, status: :created, location: @award }\n else\n format.html { render :new }\n format.json { render json: @award.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n megam_rest.post_accounts(to_hash)\n end",
"def actions\n return @actions if @actions\n @actions = Client.get(\"/organizations/#{id}/actions\").json_into(Action)\n end",
"def create\n #not sure why this was here...? @trips = Trip.all\n\n @expense_report = ExpenseReport.new(expense_report_params)\n authorize @expense_report\n @expense_report.submitter = current_account.accountable\n\n @expense_report.actual_expenses.each do |exp|\n exp.requests.each do |req|\n req.amount_from_total = req.percentrequested * exp.total\n req.destination = @expense_report.trip.destination\n req.expense_type = 'actual'\n end\n end\n\n\n respond_to do |format|\n if @expense_report.save\n format.html { redirect_to home_index_path, notice: 'Expense report was successfully created.' }\n format.json { render :show, status: :created, location: @expense_report }\n else\n format.html { render :new }\n format.json { render json: @expense_report.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n\t\tstore_location\n\n @pending_commissions \t= PayableAction.pending\n\t\t@approved_commissions = PayableAction.approved\n\t\t@paid_commissions \t\t= PayableAction.paid\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @payable_actions }\n end\n end",
"def index\n @user_actions = UserAction.all\n render json: @user_actions\n end",
"def api_post(action, data, binary_key = nil)\n api_request(action, data, 'POST', binary_key)\n end",
"def post_integrations_action_draft_with_http_info(action_id, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: IntegrationsApi.post_integrations_action_draft ...\"\n end\n \n \n # verify the required parameter 'action_id' is set\n fail ArgumentError, \"Missing the required parameter 'action_id' when calling IntegrationsApi.post_integrations_action_draft\" if action_id.nil?\n \n \n \n \n \n # resource path\n local_var_path = \"/api/v2/integrations/actions/{actionId}/draft\".sub('{format}','json').sub('{' + 'actionId' + '}', action_id.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n local_header_accept = ['application/json']\n local_header_accept_result = @api_client.select_header_accept(local_header_accept) and header_params['Accept'] = local_header_accept_result\n\n # HTTP header 'Content-Type'\n local_header_content_type = ['application/json']\n header_params['Content-Type'] = @api_client.select_header_content_type(local_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = nil\n \n auth_names = ['PureCloud Auth']\n data, status_code, headers = @api_client.call_api(:POST, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'Action')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: IntegrationsApi#post_integrations_action_draft\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def create\n @accounting_entry = AccountingEntry.new(accounting_entry_params)\n #@accounting_entry.cuenta=\"hola\"\n respond_to do |format|\n if @accounting_entry.save\n \n format.html { redirect_to accounting_entries_path, notice: 'El asiento ha sido agregado con exito' }\n format.json { render :show, status: :created, location: @accounting_entry }\n else\n format.html { render :new }\n format.json { render json: @accounting_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @tredit_action = TreditAction.new(tredit_action_params)#)#params[:tredit_action])\n\n respond_to do |format|\n if @tredit_action.save\n format.html { redirect_to @tredit_action, notice: 'Tredit action was successfully created.' }\n format.json { render json: @tredit_action, status: :created, location: @tredit_action }\n else\n format.html { render action: \"new\" }\n format.json { render json: @tredit_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def submit_order()\n\tputs \"Submitting order\"\n\tdata = create_order()\n\tresponse = request_post(\"/api/order\", data)\n\tputs response.body\nend",
"def create\n @trip = Trip.new(trip_params)\n authorize @trip\n @trip.submitter = current_account.accountable\n\n\n @trip.estimated_expenses.each do |exp|\n exp.requests.each do |req|\n req.amount_from_total = req.percentrequested * exp.total\n req.destination = @trip.destination\n req.expense_type = 'estimated'\n end\n end\n\n respond_to do |format|\n if @trip.save\n format.html { redirect_to home_index_path, notice: 'Trip was successfully created.' }\n format.json { render :show, status: :created, location: @trip }\n else\n format.html { render :new }\n format.json { render json: @trip.errors, status: :unprocessable_entity }\n end\n end\n end",
"def commit(action)\n url = endpoint_url(action)\n response_body = ssl_post(url, post_data, headers)\n #ActiveMerchant::Billing::PaysonResponse.new(response_body)\n if action.to_sym == :payment_details\n ActiveMerchant::Billing::PaysonPaymentDetailsResponse.new(response_body)\n else\n ActiveMerchant::Billing::PaysonResponse.new(response_body)\n end\n end",
"def submit\n @asset_info_adjustment = AssetInfoAdjustment.accessible_by(current_ability, :submit).find(params[:id])\n if @asset_info_adjustment.submit!(current_user)\n respond_to do |format|\n format.html { redirect_to asset_info_adjustments_url, notice: I18n.t('controllers.submit_success', name: @asset_info_adjustment.class.model_name.human) } \n format.json { head :no_content }\n format.xml { head :no_content }\n end\n else\n respond_to do |format|\n format.html { redirect_to asset_info_adjustments_url, flash: {error: @asset_info_adjustment.errors} }\n format.json { head :no_content }\n format.xml { head :no_content }\n end\n end\n end",
"def create\n @bill = Bill.new(params[:bill])\n @user = User.find(session[:user_id])\n @enterprise = Enterprise.find(@user.enterprise_id)\n @contracts = Contract.find_by_enterprise_id(@enterprise.id)\n\n respond_to do |format|\n if @bill.save\n # Update all energy goals related to this bill\n updateEnergyGoals(@bill)\n format.html { redirect_to @contracts, notice: 'Bill was successfully created.' }\n format.json { render json: @bill, status: :created, location: @bill }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def dashboard\n actions = %w(create update destroy)\n @company = current_company\n @recordings = current_company.action_recordings.where(:action => actions).limit(50)\n end",
"def create\n @current_account = @customer.current_accounts.new(current_account_params)\n\n respond_to do |format|\n if @current_account.save\n @accounting_record = CurrentAccount.create_accounting_record(@current_account.detail, @current_account.debit) \n format.html { redirect_to store_customers_path(@customer), notice: 'Current account was successfully created.' }\n format.json { render :show, status: :created, location: @current_account }\n else\n format.html { render :new }\n format.json { render json: @current_account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def action_params\n params.require(:action).permit(:name, :status, :user_id)\n end",
"def index\n @actual_action_plans = ActualActionPlan.all\n end",
"def create\n\n accountParams[:accounting_method] = accountParams[:accounting_method].to_i\n accountParams[:payor_type] = accountParams[:payor_type].to_i\n accountParams[:print_statement] = accountParams[:print_statement].to_i\n accountParams[:rx_charge_description] = accountParams[:rx_charge_description].to_i\n accountParams[:statement_type] = accountParams[:statement_type].to_i\n\n @account = Account.new(account_params)\n\n respond_to do |format|\n if @account.save\n format.html { redirect_to @account, notice: 'Account was successfully created.' }\n format.json { render :show, status: :created, location: @account }\n else\n format.html { render :new }\n format.json { render json: @account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @accounting_action.destroy\n respond_to do |format|\n format.html { redirect_to accounting_actions_url, notice: 'Ação foi destruída com sucesso.' }\n format.json { head :no_content }\n end\n end",
"def task_action\n action = params[:task_action]\n @task.update status: action \n respond_to do |format|\n format.html { redirect_to edit_ticket_path(@ticket), notice: \"Task #{action}.\" }\n format.json { head :no_content }\n end\n end",
"def create\n @actions = [] unless defined?(@actions)\n @actions << :create\n end",
"def sale_action\n @json_body['sale_action']\n end",
"def create\n @action_report = ActionReport.new(action_report_params)\n\n respond_to do |format|\n if @action_report.save\n format.html { redirect_to @action_report, notice: 'Action report was successfully created.' }\n format.json { render :show, status: :created, location: @action_report }\n else\n format.html { render :new }\n format.json { render json: @action_report.errors, status: :unprocessable_entity }\n end\n end\n end",
"def creditCardIndex\n render json: Approved.allCreditCard\n end",
"def wallet_action_params\n params.require(:wallet_action).permit(:wallet_id, :action_type, :amount)\n end",
"def create\n @transaction = Transaction.new(params[:transaction])\n\n respond_to do |format|\n if @transaction.save\n format.html { redirect_to account_transactions_path(@transaction.account), notice: 'Transaction was successfully created.' }\n format.json { render json: @transaction, status: :created, location: @transaction }\n else\n format.html { redirect_to account_transactions_path(current_user.accounts.expense_accounts.first), alert: 'Transaction could not be added.' }\n format.json { render json: @transaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\r\n @aes_action = Action.new(aes_action_params)\r\n\r\n respond_to do |format|\r\n if @aes_action.save\r\n format.html { redirect_to @aes_action, notice: 'Aes action was successfully created.' }\r\n format.json { render :show, status: :created, location: @aes_action }\r\n else\r\n format.html { render :new }\r\n format.json { render json: @aes_action.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create\n @opportunity = Opportunity.new(params[:opportunity])\n\n respond_to do |format|\n if @opportunity.save\n format.html { redirect_to @opportunity, notice: 'Opportunity was successfully created.' }\n format.json { render json: @opportunity, status: :created, location: @opportunity }\n else\n @supplier_accounts = SupplierAccount.approved.order 'fantasy_name'\n \n format.html { render action: \"new\" }\n format.json { render json: @opportunity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @actionable = Actionable.new(actionable_params)\n\n respond_to do |format|\n if @actionable.save\n format.html { redirect_to @actionable, notice: 'Actionable was successfully created.' }\n format.json { render :show, status: :created, location: @actionable }\n else\n format.html { render :new }\n format.json { render json: @actionable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def accounting_params\n params.require(:accounting).permit(:id)\n end",
"def create\n megam_rest.post_billedhistories(to_hash)\n end",
"def index\n @due_actions = DueAction.all\n end",
"def post(action, params={}, options={})\n request(:post, action, params, options)\n end",
"def asset_action\n\n #proxy = SchedulerActionProxy.new(params[:scheduler_action_proxy])\n\n case proxy.action_id\n when ASSET_REPLACE_ACTION\n Rails.logger.debug \"Updating asset #{asset.object_key}. New scheduled replacement year = #{proxy.fy_year.to_i}\"\n asset.scheduled_replacement_year = proxy.fy_year.to_i if proxy.fy_year\n asset.replacement_reason_type_id = proxy.reason_id.to_i if proxy.reason_id\n asset.scheduled_replacement_cost = proxy.replace_cost.to_i if proxy.replace_cost\n asset.scheduled_replace_with_new = proxy.replace_with_new.to_i if proxy.replace_with_new\n updated = true\n asset.save\n #notify_user :notice, \"#{asset.asset_subtype}: #{asset.asset_tag} #{asset.description} is scheduled for replacement in #{fiscal_year(proxy.year.to_i)}\"\n\n when ASSET_REHABILITATE_ACTION\n asset.scheduled_rehabilitation_year = proxy.fy_year.to_i\n asset.scheduled_replacement_year = asset.scheduled_rehabilitation_year + proxy.extend_eul_years.to_i\n asset.scheduled_rehabilitation_cost = proxy.rehab_cost.to_i\n updated = true\n asset.save\n #notify_user :notice, \"#{asset.asset_subtype}: #{asset.asset_tag} #{asset.description} is now scheduled for replacement in #{fiscal_year(proxy.replace_fy_year.to_i)}\"\n\n when ASSET_REMOVE_FROM_SERVICE_ACTION\n asset.scheduled_rehabilitation_year = nil\n asset.scheduled_replacement_year = nil\n asset.scheduled_replacement_cost = nil\n asset.scheduled_replace_with_new = nil\n asset.scheduled_rehabilitation_cost = nil\n asset.scheduled_disposition_year = proxy.fy_year.to_i\n updated = true\n asset.save\n\n when ASSET_RESET_ACTION\n asset.scheduled_rehabilitation_year = nil\n asset.scheduled_replacement_year = asset.policy_replacement_year\n asset.scheduled_disposition_year = nil\n asset.scheduled_replacement_cost = nil\n asset.scheduled_replace_with_new = nil\n asset.scheduled_rehabilitation_cost = nil\n updated = true\n asset.save\n\n end\n\n # Update the capital projects with this new data\n if updated\n CapitalProjectBuilder.new.update_asset_schedule(asset)\n end\n\n end",
"def credit\n handle_response(get(\"/credit.json\"))\n end",
"def add_create_action(options = {})\n post '/' do\n item = model.new permitted_params\n authorize item, :create? if options[:authorize]\n if item.save\n present item, with: entity_class\n else\n error!({ errors: item.errors.messages }, 422)\n end\n end\n end",
"def sellcertificates(action)\n action.create_transaction\n end",
"def actions\n @actions = []\n price = compute_price('level2')\n commission = (price * 0.3).to_i\n insurance_fee = (commission / 2).to_i\n assistance_fee = duration * 100\n owner_fee = price - (price * 0.3).to_i\n drivy_fee = commission - insurance_fee - assistance_fee\n @options.each do |option|\n case option.type\n when 'gps'\n price += option_price_per_day('gps') * duration * 100\n owner_fee += option_price_per_day('gps') * duration * 100\n when 'baby_seat'\n price += option_price_per_day('baby_seat') * duration * 100\n owner_fee += option_price_per_day('baby_seat') * duration * 100\n when 'additional_insurance'\n price += option_price_per_day('additional_insurance') * duration * 100\n drivy_fee += option_price_per_day('additional_insurance') * duration * 100\n end\n end\n if price != 0\n @actions << Action.new(who: 'driver', type: 'debit', amount: price)\n @actions << Action.new(who: 'owner', type: 'credit', amount: owner_fee)\n @actions << Action.new(who: 'insurance', type: 'credit', amount: insurance_fee)\n @actions << Action.new(who: 'assistance', type: 'credit', amount: assistance_fee)\n @actions << Action.new(who: 'drivy', type: 'credit', amount: drivy_fee)\n end\n @actions.collect { |action| action.convert_to_hash }\n end",
"def actions\n act = []\n act << 'capture' if can_capture? payment\n act << 'void' if can_void? payment\n act\n end",
"def formula_action_params\n params.require(:formula_action).permit(:formula_id, :formula_named_action_id)\n end",
"def add_tenant_circle(args = {}) \n post(\"/tenantcircles.json/\", args)\nend",
"def available_actions\n [\n Action::BuyCertificate,\n Action::Pass,\n Action::SellCertificates,\n Action::StartCompany\n ]\n end",
"def exec_action(money, payment, action, options={})\n raise ArgumentError, \"Money should be a positive integer in cents\" if money < 0 \n raise ArgumentError, \"Payment should be a token string or a CreditCard object\" if !payment\n requires!(options, :id)\n post = {}\n add_invoice(post, money, options)\n add_payment(post, payment)\n add_customer_data(post, options)\n add_parmx(post, options)\n\n commit(action, post)\n end",
"def actions\n res = []\n res << :capture if payment.pending?\n res << :void if payment.completed?\n res\n end",
"def actions\n res = []\n res << :capture if payment.pending?\n res << :void if payment.completed?\n res\n end",
"def post_integrations_actions(body, opts = {})\n data, _status_code, _headers = post_integrations_actions_with_http_info(body, opts)\n return data\n end",
"def add_actions; end",
"def create\n @automated_transaction = AutomatedTransaction.new(automated_transaction_params)\n @automated_transaction.airport_id = current_airport.id\n if @automated_transaction.account\n @automated_transaction.registration = @automated_transaction.account.registration\n end\n respond_to do |format|\n if @automated_transaction.save\n format.html { redirect_to automated_transactions_path, notice: 'Automated transaction was successfully created.' }\n format.json { render :show, status: :created, location: automated_transactions_path }\n else\n format.html { render :new }\n format.json { render json: @automated_transaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_data(action, parameters = {})\n\n # Init default hash\n keys = []\n\n # Create the data hash with mendatory fields\n data = { userName: @options[:login],\n password: @options[:password],\n termNo: @options[:terminal_no],\n shopNo: @options[:shop_no] }\n\n # Merge the params into the final hash\n data.merge!(parameters)\n\n # Check action\n case action\n when \"sale\"\n keys = [:creditCard, :creditCardDateMmyy, :token, :total, :currency, :cvv2, :id, :authNum,\n :parmx]\n when \"authonly\"\n keys = [:creditCard, :creditCardDateMmyy, :token, :total, :currency, :cvv2, :id, :parmx]\n when \"check_error\"\n keys = [:code]\n when \"check_login\"\n keys = []\n else\n raise ArgumentError, \"Action: #{action} is not supported\"\n end\n \n # Ensure all fields are inserted. If not create them blank\n keys.each { |x| check_or_create_for!(data, x) }\n\n # Turn the hash into a string\n data.collect { |key, value| \"#{key}=#{CGI.escape(value.to_s)}\" }.join(\"&\")\n end",
"def create\n @xaction = Xaction.new(params[:xaction])\n\n respond_to do |format|\n if @xaction.save\n format.html { redirect_to @xaction, notice: 'Xaction was successfully created.' }\n format.json { render json: @xaction, status: :created, location: @xaction }\n else\n format.html { render action: \"new\" }\n format.json { render json: @xaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def calendar_action_params\n params.require(:calendar_action).permit(:holder, :title, :icon, :description, :responsible, :text_color, :color, :action_type)\n end",
"def create\n #@transaction_entry = TransactionEntry.new(params[:transaction_entry])\n @transaction_entry = TransactionEntry.new(params.require(:transaction_entry).permit(:debit_amount, :tranxaction_id, :account_id))\n\n respond_to do |format|\n if @transaction_entry.save\n format.html { redirect_to @transaction_entry, :notice => 'Transaction entry was successfully created.' }\n format.json { render :json => @transaction_entry, :status => :created, :location => @transaction_entry }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @transaction_entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def commit(action, xml)\n headers = { 'Content-Type' => 'application/x-qbmsxml',\n 'Content-length' => xml.size.to_s }\n \n # Post to server\n url = get_post_url\n @request = xml\n data = ssl_post(url, xml, headers)\n \n response = parse(action, data)\n message = message_from(response)\n \n # Post Processing - Create the Response object\n case action\n \n when 'session_ticket'\n @response = Response.new(success?(response), message, response, \n :test => test?,\n :authorization => response[:session_ticket]\n )\n @response\n \n else\n @response = Response.new(success?(response), message, response, \n :test => test?,\n :authorization => response[:transaction_id],\n :cvv_result => cvv_result(response),\n :avs_result => avs_result(response)\n ) \n end\n end",
"def action_report_params\n params.require(:action_report).permit(:pilot_id, :airframe_id, :tasking_id, :hours, :takeoffs, :landings, :outcome, :aa_kills, :ag_kills, :notes, :status, :position )\n end",
"def createTransaction(toAcc, json)\n\t\turl = \"#{self.urlWithEntity}/#{toAcc}/transactions?key=#{self.apiKey}\"\n\t\turi = URI.parse(url)\n\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\trequest = Net::HTTP::Post.new(uri.request_uri, initheader = {'Content-Type' => 'application/json'})\n\t\trequest.body = json\n\t\tresp = http.request(request)\n\tend",
"def index\n @buy_actions = BuyAction.all\n end",
"def create\n @user_action = UserAction.new(user_action_params)\n\n respond_to do |format|\n if @user_action.save\n format.html { redirect_to @user_action, notice: 'User action was successfully created.' }\n format.json { render :show, status: :created, location: @user_action }\n else\n format.html { render :new }\n format.json { render json: @user_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @payout = Payout.new(price: current_user.credit, user_id: current_user.id)\n ti_ids = TaskInstance.where('status = ? AND user_id = ?', :finished, current_user.id).select(:id)\n ti_ids.each do |ti|\n ti.update(status: :paid)\n end\n @payout.task_instances = ti_ids\n\n respond_to do |format|\n if @payout.save\n current_user.update(credit: 0)\n format.html { redirect_to @payout, notice: 'Payout was successfully created.' }\n format.json { render action: 'show', status: :created, location: @payout }\n else\n format.html { render action: 'new' }\n format.json { render json: @payout.errors, status: :unprocessable_entity }\n end\n end\n end",
"def commit(action, params = {})\n unless VALID_ACTIONS.include? action.to_sym\n raise \"Invalid action\"\n end\n @action = action\n @params = params\n \n conn = Faraday.new(:url => API_URL) do |c|\n c.request :soap\n c.response :soap, \"item\"\n c.adapter :net_http\n end\n \n request = conn.post do |r|\n r.body = format_params_for_fantastico\n r.headers = {'Content-Type' => 'text/xml; charset=utf-8'}\n end\n \n response = request.body\n \n @success = !(response.is_a?(Hash) && response.has_key?(\"faultcode\"))\n \n response\n end",
"def post_aliases(actions)\n resp = post do |req|\n req.url \"/_aliases\"\n req.body = { :actions => Array.new(actions) }\n end\n resp.body\n end",
"def create\n @acct = EmployeeAcct.new(employee_acct_params)\n @acct.account = current_account\n\n respond_to do |format|\n if @acct.save\n format.html { redirect_to \"/\", notice: 'Employee Account was successfully created.' }\n format.json { redirect_to \"/\", status: :created, location: @acct }\n else\n format.html { render :new }\n format.json { render json: @acct.errors, status: :unprocessable_entity }\n end\n end\n end",
"def deposit\n request_params = params.permit(:source_account_id, :destination_account_id, :amount)\n\n bank ||= Actions.new.deposit(\n request_params['source_account_id'], \n request_params['destination_account_id'], \n request_params['amount']\n )\n\n return render status: bank[0], json: bank[1]\n end",
"def index\n redirect_to :action => 'request_bill'\n end",
"def create\r\n @account_x_entry = AccountXEntries.new(account_x_entry_params)\r\n\r\n respond_to do |format|\r\n if @account_x_entry.save\r\n format.html { redirect_to @account_x_entry, notice: 'Detail of cash movement was successfully created.' }\r\n format.json { render :show, status: :created, location: @account_x_entry }\r\n else\r\n format.html { render :new }\r\n format.json { render json: @account_x_entry.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create_batch\n all_months.each do |month|\n cash_flow = find_or_build_cash_flow(month, @category.id)\n\n cash_flow.planned = cash_flow_params[:value]\n cash_flow.save!\n end\n\n render json: { success: true }, status: :created\n end",
"def index\r\n @aes_actions = Action.all\r\n end",
"def create\n @tempacct = Tempacct.new(tempacct_params)\n authorize! :create, @tempacct\n respond_to do |format|\n if @tempacct.save\n #format.html { redirect_to @tempacct, notice: 'Tempacct was successfully created.' }\n format.html { redirect_to session[:tempacct_page], notice: 'Temporary account was successfully created.' }\n format.json { render action: 'show', status: :created, location: @tempacct }\n else\n format.html { render action: 'new' }\n format.json { render json: @tempacct.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @admin_accounting_bank_account = Admin::AccountingBankAccount.new(params[:admin_accounting_bank_account])\n\n respond_to do |format|\n if @admin_accounting_bank_account.save\n format.html { redirect_to admin_accounting_bank_accounts_url}\n format.json { render json: @admin_accounting_bank_account, status: :created, location: @admin_accounting_bank_account }\n else\n format.html { render action: \"new\" }\n format.json { render json: @admin_accounting_bank_account.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.6284859",
"0.626547",
"0.5944006",
"0.58842224",
"0.5829392",
"0.58125216",
"0.57616407",
"0.5703602",
"0.5680716",
"0.56638485",
"0.56456524",
"0.56299907",
"0.55586106",
"0.5556023",
"0.5502889",
"0.54391885",
"0.54363555",
"0.54347336",
"0.542592",
"0.5409714",
"0.54069066",
"0.53993237",
"0.5397959",
"0.5386301",
"0.5377232",
"0.5355888",
"0.53546405",
"0.5344811",
"0.534208",
"0.53240687",
"0.5323734",
"0.5322779",
"0.53169346",
"0.5314851",
"0.5312651",
"0.530935",
"0.530477",
"0.5298799",
"0.52915955",
"0.52886814",
"0.5284727",
"0.5278706",
"0.52702314",
"0.5256771",
"0.52408403",
"0.5223762",
"0.5217379",
"0.52132636",
"0.52072823",
"0.519718",
"0.5194978",
"0.5187202",
"0.5181438",
"0.5178593",
"0.51763517",
"0.5176196",
"0.51510143",
"0.515065",
"0.5143761",
"0.51429623",
"0.51407903",
"0.5139671",
"0.51369333",
"0.5135763",
"0.513438",
"0.51292515",
"0.51276004",
"0.51219267",
"0.512009",
"0.51156825",
"0.5115427",
"0.51130325",
"0.5102926",
"0.5098759",
"0.50975436",
"0.50966907",
"0.50966907",
"0.5096538",
"0.50952333",
"0.509504",
"0.50902486",
"0.50879526",
"0.5084372",
"0.5083562",
"0.50826705",
"0.50817144",
"0.5078968",
"0.50773704",
"0.5076239",
"0.50684047",
"0.5064115",
"0.50622225",
"0.50617325",
"0.5060467",
"0.5057528",
"0.50567275",
"0.5054904",
"0.50544393",
"0.50530124",
"0.5043975"
] | 0.68680024 | 0 |
PATCH/PUT /accounting_actions/1 PATCH/PUT /accounting_actions/1.json | def update
respond_to do |format|
if @accounting_action.update(accounting_action_params)
format.html { redirect_to @accounting_action, notice: 'Ação foi atualizada com sucesso.' }
format.json { render :show, status: :ok, location: @accounting_action }
else
format.html { render :edit }
format.json { render json: @accounting_action.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n head :forbidden\n\n #@action = Action.find(params[:id])\n\n #if @action.update_attributes(params[:action])\n # head :no_content\n # else\n # render json: @action.errors, status: :unprocessable_entity\n # end\n end",
"def patch(action, **args); end",
"def update\n @payable_action = PayableAction.find(params[:id])\n\n respond_to do |format|\n if @payable_action.update_attributes(params[:payable_action])\n flash[:notice] = 'PayableAction was successfully updated.'\n format.html { redirect_to([:admin, @payable_action]) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @payable_action.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n contract = Contract.find_by_id(params[:id])\n (head :unauthorized unless contract) and return\n \n # try to update the attributes\n if contract.update_attributes(edit_contract_params)\n render json: contract\n else\n render json: { errors: contract.error.full_messages}\n end\n end",
"def update\n respond_to do |format|\n if @cta.update(cta_params)\n format.html { redirect_to @cta, notice: 'cta was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @cta.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize AccountingEntry\n\n respond_to do |format|\n if @accounting_entry.update(accounting_entry_params)\n format.html { redirect_to show_accounting_for_loan_loan_path(@accounting_entry.accounting_book.loan), notice: 'Accounting entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @accounting_entry }\n else\n format.html { render :edit }\n format.json { render json: @accounting_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_accounting_action\n @accounting_action = AccountingAction.find(params[:id])\n end",
"def update\n @accessory_act = AccessoryAct.find(params[:id])\n\n respond_to do |format|\n if @accessory_act.update_attributes(params[:accessory_act])\n format.html { redirect_to @accessory_act, :notice => 'Accessory act was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @accessory_act.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @expense_report\n\n\n @expense_report.actual_expenses.each do |exp|\n exp.requests.each do |req|\n req.amount_from_total = req.percentrequested * exp.total\n req.destination = @expense_report.trip.destination\n req.expense_type = 'actual'\n end\n end\n\n\n respond_to do |format|\n if @expense_report.update(expense_report_params)\n format.html { redirect_to @expense_report, notice: 'Expense report was successfully updated.' }\n format.json { render :show, status: :ok, location: @expense_report }\n else\n format.html { render :edit }\n format.json { render json: @expense_report.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @next_action = NextAction.find(params[:id])\n\n respond_to do |format|\n if @next_action.update_attributes(params[:act])\n format.html { redirect_to @next_action, notice: 'Next Action was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @next_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @payable = Payable.find(params[:id])\n # params[:payable][:payable_accounts_attributes] = @payable.process_removed_accounts(params[:payable][:payable_accounts_attributes])\n\n # Updating GlAccount\n # accountsPayableAmt = 0\n # @payable.payable_accounts.each do |payable_account|\n # CommonActions.update_gl_accounts(payable_account.gl_account.gl_account_title, 'decrement',payable_account.payable_account_amount, @payable.id )\n # accountsPayableAmt += payable_account.payable_account_amount\n # end\n # CommonActions.update_gl_accounts('ACCOUNTS PAYABLE', 'decrement',accountsPayableAmt, @payable.id )\n\n respond_to do |format|\n if @payable.update_attributes(payable_params)\n if Payable.find_by_payable_disperse(\"unassigned\").present?\n payable = Payable.find_by_payable_disperse(\"unassigned\")\n payable.update_attributes(:payable_disperse => \"assigned\")\n end\n # @payable.update_gl_account\n format.html { redirect_to @payable, notice: 'Payable was successfully updated.' }\n format.json { head :no_content }\n else\n p @payable.errors.to_json\n if @payable.payable_type == 'manual'\n format.html { render action: \"manual_edit\" }\n format.json { render json: @payable.errors, status: :unprocessable_entity }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @payable.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def update\n @opportunity = Opportunity.find(params[:id])\n\n respond_to do |format|\n if @opportunity.update_attributes(params[:opportunity])\n format.html { redirect_to @opportunity, notice: 'Opportunity was successfully updated.' }\n format.json { head :ok }\n else\n @supplier_accounts = SupplierAccount.approved.order 'fantasy_name'\n \n format.html { render action: \"edit\" }\n format.json { render json: @opportunity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @accounting_entry.update(accounting_entry_params)\n format.html { redirect_to @accounting_entry, notice: 'Se ha actualizado con exito.' }\n format.json { render :show, status: :ok, location: @accounting_entry }\n else\n format.html { render :edit }\n format.json { render json: @accounting_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @tredit_action = TreditAction.find(params[:id])\n\n respond_to do |format|\n if @tredit_action.update_attributes(params[:tredit_action])\n format.html { redirect_to @tredit_action, notice: 'Tredit action was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @tredit_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def task_action\n action = params[:task_action]\n @task.update status: action \n respond_to do |format|\n format.html { redirect_to edit_ticket_path(@ticket), notice: \"Task #{action}.\" }\n format.json { head :no_content }\n end\n end",
"def update\n respond_to do |format|\n if @buy_action.update(buy_action_params)\n format.html { redirect_to admin_path, notice: 'Buy action was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @buy_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n resource.update(deposit_contract_params)\n respond_with client, resource\n end",
"def update\n keystone.update_tenant({:id=>params[:id],:name=>params[:name],:description=>params[:description],:enabled=>params[:enabled]})\n respond_to do |format|\n format.html { redirect_to tenants_path, :notice => 'Tenant was successfully updated.' }\n format.json { head :ok }\n end\n end",
"def update\n respond_to do |format|\n if @accounting_account.update(accounting_account_params)\n format.js { }\n else\n format.html { render :edit }\n format.json { render json: @accounting_account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @xaction = Xaction.find(params[:id])\n\n respond_to do |format|\n if @xaction.update_attributes(params[:xaction])\n format.html { redirect_to @xaction, notice: 'Xaction was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @xaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @operations_check = OperationsCheck.find(params[:id])\n\n respond_to do |format|\n if @operations_check.update_attributes(operations_check_params)\n format.html { redirect_to @operations_check, \n notice: 'Operations check was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @operations_check.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @step = TaskrequestsStep.find(params[:taskrequests_step_id])\n @absence_request = @step.absence_requests.find(params[:id])\n\n respond_to do |format|\n if @absence_request.update_attributes(params[:absence_request])\n format.html { redirect_to(@absence_request, :notice => 'Absence request was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @absence_request.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @trip\n\n\n @trip.estimated_expenses.each do |exp|\n exp.requests.each do |req|\n req.amount_from_total = req.percentrequested * exp.total\n req.destination = @trip.destination\n req.expense_type = 'estimated'\n end\n end\n\n respond_to do |format|\n if @trip.update(trip_params)\n format.html { redirect_to @trip, notice: 'Trip was successfully updated.' }\n format.json { render :show, status: :ok, location: @trip }\n else\n format.html { render :edit }\n format.json { render json: @trip.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @tredit_action = TreditAction.find(params[:id])\n\n respond_to do |format|\n if @tredit_action.update(tredit_action_params)#)#params[:tredit_action], :without_protection => true)\n format.html { redirect_to @tredit_action, notice: 'Tredit action was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @tredit_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n render status: 501, json: { errors: ['Action not implemented yet!'] }\n end",
"def update\n \n @act = Act.find(params[:id])\n\n respond_to do |format|\n if @act.update_attributes(params[:act])\n format.html { redirect_to acts_path, notice: 'act was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @act.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @actual_action_plan.update(actual_action_plan_params)\n format.html { redirect_to @actual_action_plan, notice: 'Actual action plan was successfully updated.' }\n format.json { render :show, status: :ok, location: @actual_action_plan }\n else\n format.html { render :edit }\n format.json { render json: @actual_action_plan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @actionable.update(actionable_params)\n format.html { redirect_to @actionable, notice: 'Actionable was successfully updated.' }\n format.json { render :show, status: :ok, location: @actionable }\n else\n format.html { render :edit }\n format.json { render json: @actionable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update \n begin\n @resource = Account.find(params[:id])\n @resource.update_attributes!(params[:account])\n render :response => :PUT\n rescue Exception => e\n @error = process_exception(e)\n render :response => :error\n end\n end",
"def update!(**args)\n @successful_actions = args[:successful_actions] if args.key?(:successful_actions)\n @total_actions = args[:total_actions] if args.key?(:total_actions)\n end",
"def update\n @account = Account.find(params[:id])\n\n respond_to do |format|\n if @account.update_attributes(params[:account])\n format.html { redirect_to @account, :notice => 'Account was successfully updated.' }\n format.json { head :ok }\n else\n @suppliers = Supplier.all(:order=>:name).collect{|c| [c.name, c.id]}\n @aircraft_types = AircraftType.all(:order => :name).collect{|c| [c.name, c.id]}\n\n format.html { render :action => \"edit\" }\n format.json { render :json => @account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @accounting_item = Accounting::Item.find_by(id: params[:id], user_id: @current_user.id)\n logger.info @accounting_item.inspect\n\n respond_to do |format|\n if @accounting_item.update(item_params)\n format.json { head :no_content }\n else\n format.json { render json: @accounting_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @ipc_all_ac.update(ipc_all_ac_params)\n format.html { redirect_to @ipc_all_ac, notice: 'Ipc all ac was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @ipc_all_ac.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # build_resource\n if resource.status == 'Open'\n resource.update_attributes permitted_params[:contract]\n if !resource.valid?\n render json: resource.errors, status: :unprocessable_entity\n else\n resource.save\n respond_with json: {}, status: :ok\n end\n else\n respond_with json: [{'error':'The contract must be Open to edit.'}], status: :unprocessable_entity\n end\n end",
"def update_rest\n @entry_item = EntryItem.find(params[:id])\n\n respond_to do |format|\n if @entry_item.update_attributes(params[:entry_item])\n flash[:notice] = 'EntryItem was successfully updated.'\n #format.html { redirect_to(@entry_item) }\n format.xml { head :ok }\n else\n #format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry_item.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @action_name = ActionName.find(params[:id])\n\n respond_to do |format|\n if @action_name.update_attributes(params[:action_name])\n format.html { redirect_to @action_name, notice: 'Action name was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @action_name.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tenant_circle(args = {}) \n put(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def update\n respond_to do |format|\n if @ticket.update(ticket_params)\n @ticket.update_responsible(:status, 'Waiting for Staff Response')\n format.html { redirect_to @ticket, notice: 'Ticket was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @ticket.errors, status: :unprocessable_entity }\n end\n end\n end",
"def asset_action\n\n #proxy = SchedulerActionProxy.new(params[:scheduler_action_proxy])\n\n case proxy.action_id\n when ASSET_REPLACE_ACTION\n Rails.logger.debug \"Updating asset #{asset.object_key}. New scheduled replacement year = #{proxy.fy_year.to_i}\"\n asset.scheduled_replacement_year = proxy.fy_year.to_i if proxy.fy_year\n asset.replacement_reason_type_id = proxy.reason_id.to_i if proxy.reason_id\n asset.scheduled_replacement_cost = proxy.replace_cost.to_i if proxy.replace_cost\n asset.scheduled_replace_with_new = proxy.replace_with_new.to_i if proxy.replace_with_new\n updated = true\n asset.save\n #notify_user :notice, \"#{asset.asset_subtype}: #{asset.asset_tag} #{asset.description} is scheduled for replacement in #{fiscal_year(proxy.year.to_i)}\"\n\n when ASSET_REHABILITATE_ACTION\n asset.scheduled_rehabilitation_year = proxy.fy_year.to_i\n asset.scheduled_replacement_year = asset.scheduled_rehabilitation_year + proxy.extend_eul_years.to_i\n asset.scheduled_rehabilitation_cost = proxy.rehab_cost.to_i\n updated = true\n asset.save\n #notify_user :notice, \"#{asset.asset_subtype}: #{asset.asset_tag} #{asset.description} is now scheduled for replacement in #{fiscal_year(proxy.replace_fy_year.to_i)}\"\n\n when ASSET_REMOVE_FROM_SERVICE_ACTION\n asset.scheduled_rehabilitation_year = nil\n asset.scheduled_replacement_year = nil\n asset.scheduled_replacement_cost = nil\n asset.scheduled_replace_with_new = nil\n asset.scheduled_rehabilitation_cost = nil\n asset.scheduled_disposition_year = proxy.fy_year.to_i\n updated = true\n asset.save\n\n when ASSET_RESET_ACTION\n asset.scheduled_rehabilitation_year = nil\n asset.scheduled_replacement_year = asset.policy_replacement_year\n asset.scheduled_disposition_year = nil\n asset.scheduled_replacement_cost = nil\n asset.scheduled_replace_with_new = nil\n asset.scheduled_rehabilitation_cost = nil\n updated = true\n asset.save\n\n end\n\n # Update the capital projects with this new data\n if updated\n CapitalProjectBuilder.new.update_asset_schedule(asset)\n end\n\n end",
"def update!(**args)\n @actions = args[:actions] if args.key?(:actions)\n end",
"def update!(**args)\n @actions = args[:actions] if args.key?(:actions)\n end",
"def update!(**args)\n @actions = args[:actions] if args.key?(:actions)\n end",
"def update!(**args)\n @actions = args[:actions] if args.key?(:actions)\n end",
"def update\n @operation = Operation.find(params[:id])\n\n respond_to do |format|\n if @operation.update_attributes(operation_params)\n format.html { redirect_to @operation, notice: 'Operation was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @operation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @breadcrumb = 'update'\n @contracting_request_document_type = ContractingRequestDocumentType.find(params[:id])\n @contracting_request_document_type.updated_by = current_user.id if !current_user.nil?\n\n respond_to do |format|\n if @contracting_request_document_type.update_attributes(params[:contracting_request_document_type])\n format.html { redirect_to @contracting_request_document_type,\n notice: (crud_notice('updated', @contracting_request_document_type) + \"#{undo_link(@contracting_request_document_type)}\").html_safe }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @contracting_request_document_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @contact_action = ContactAction.find(params[:id])\n\n respond_to do |format|\n if @contact_action.update_attributes(params[:contact_action])\n format.html { redirect_to @contact_action, notice: 'Contact action was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @contact_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n if is_adm? && params[:type] == 'complete'\n request = MaintenanceRequest.find(maintenance_request_params[:ticket_no])\n request.app_status = 2\n request.save\n redirect_to maintenance_requests_url\n return\n else\n @maintenance_request = MaintenanceRequest.find(params[:id])\n end\n\n respond_to do |format|\n if @maintenance_request.update(maintenance_request_params)\n format.html { redirect_to @maintenance_request, notice: 'Maintenance request was successfully updated.' }\n format.json { render :show, status: :ok, location: @maintenance_request }\n else\n format.html { render :edit }\n format.json { render json: @maintenance_request.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @az_operation = AzOperation.find(params[:id])\n\n respond_to do |format|\n if @az_operation.update_attributes(params[:az_operation])\n flash[:notice] = 'AzOperation was successfully updated.'\n format.html { redirect_to(edit_az_operation_path(@az_operation)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @az_operation.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @alarm_action.update(alarm_action_params)\n format.html { redirect_to @alarm_action, notice: 'Alarm action was successfully updated.' }\n format.json { render :show, status: :ok, location: @alarm_action }\n else\n format.html { render :edit }\n format.json { render json: @alarm_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @appliance\n respond_to do |format|\n if @appliance.update(appliance_params)\n @appliance.fire_transition(params[:transanction]) unless params[:transanction].nil?\n format.html { redirect_to @appliance, notice: 'Appliance was successfully updated.' }\n format.json { render :show, status: :ok, location: @appliance }\n else\n format.html { render :edit }\n format.json { render json: @appliance.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @actum.update(actum_params)\n format.html { redirect_to @actum, notice: 'Actum was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @actum.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_with Expense.update(params[:id], expense_params), status: 204\n end",
"def update\n @adjustment_account = AdjustmentAccount.find(params[:id])\n if params[:combo][:value] == \"Credit\"\n params[:adjustment_account][:debit_credit] = 1 \n else\n params[:adjustment_account][:debit_credit] = 0 \n end\n\n respond_to do |format|\n if @adjustment_account.update_attributes(params[:adjustment_account])\n flash[:notice] = 'Kode Rekening AJE berhasil diupdate.'\n format.html { redirect_to(accounting_adjustment_accounts_path) }\n format.xml { head :ok }\n else\n flash[:notice] = 'Kode Rekening AJE gagal diupdate.'\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @adjustment_account.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cashbox.update(cashbox_params)\n format.html { redirect_to @cashbox, notice: 'Cashbox was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @cashbox.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @wallet_action.update(wallet_action_params)\n format.html { redirect_to @wallet_action, notice: 'Wallet action was successfully updated.' }\n format.json { render :show, status: :ok, location: @wallet_action }\n else\n format.html { render :edit }\n format.json { render json: @wallet_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_expense.update(api_v1_expense_params)\n format.html { redirect_to @api_v1_expense, notice: 'Expense was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_expense }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_rest\n @entry_answer = EntryAnswer.find(params[:id])\n\n respond_to do |format|\n if @entry_answer.update_attributes(params[:entry_answer])\n flash[:notice] = 'EntryAnswer was successfully updated.'\n format.html { redirect_to(@entry_answer) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry_answer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def patch_integrations_action_draft_with_http_info(action_id, body, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug \"Calling API: IntegrationsApi.patch_integrations_action_draft ...\"\n end\n \n \n # verify the required parameter 'action_id' is set\n fail ArgumentError, \"Missing the required parameter 'action_id' when calling IntegrationsApi.patch_integrations_action_draft\" if action_id.nil?\n \n \n \n \n \n \n # verify the required parameter 'body' is set\n fail ArgumentError, \"Missing the required parameter 'body' when calling IntegrationsApi.patch_integrations_action_draft\" if body.nil?\n \n \n \n \n \n # resource path\n local_var_path = \"/api/v2/integrations/actions/{actionId}/draft\".sub('{format}','json').sub('{' + 'actionId' + '}', action_id.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n\n # HTTP header 'Accept' (if needed)\n local_header_accept = ['application/json']\n local_header_accept_result = @api_client.select_header_accept(local_header_accept) and header_params['Accept'] = local_header_accept_result\n\n # HTTP header 'Content-Type'\n local_header_content_type = ['application/json']\n header_params['Content-Type'] = @api_client.select_header_content_type(local_header_content_type)\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = @api_client.object_to_http_body(body)\n \n auth_names = ['PureCloud Auth']\n data, status_code, headers = @api_client.call_api(:PATCH, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'Action')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: IntegrationsApi#patch_integrations_action_draft\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def update\n respond_to do |format|\n if @acct_transaction.update(acct_transaction_params)\n format.html { redirect_to @acct_transaction, notice: 'Acct transaction was successfully updated.' }\n format.json { render :show, status: :ok, location: @acct_transaction }\n else\n format.html { render :edit }\n format.json { render json: @acct_transaction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @contract.update(update_params)\n format.html { redirect_to_leaf_notice(UPDATE_SUCCESS) }\n format.json { render :show, status: :ok, location: @contract }\n else\n unprocessable_response(format)\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_initiative_update.update(api_v1_initiative_update_params)\n format.html { redirect_to @api_v1_initiative_update, notice: 'Initiative update was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_initiative_update }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_initiative_update.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_rest\n @item_usage = ItemUsage.find(params[:id])\n\n respond_to do |format|\n if @item_usage.update_attributes(params[:item_usage])\n flash[:notice] = 'ItemUsage was successfully updated.'\n format.html { redirect_to(@item_usage) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @item_usage.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n render json: Company.update(params[\"id\"], params[\"company\"])\n end",
"def update\n @ticket_action = TicketAction.find(params[:id])\n\n respond_to do |format|\n if @ticket_action.update_attributes(params[:ticket_action])\n flash[:notice] = 'TicketAction was successfully updated.'\n format.html { redirect_to(@ticket_action) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @ticket_action.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\r\n respond_to do |format|\r\n if @owner_commission.update(owner_commission_params)\r\n format.html { redirect_to @owner_commission, notice: 'Owner commission was successfully updated.' }\r\n format.json { head :no_content }\r\n else\r\n format.html { render action: 'edit' }\r\n format.json { render json: @owner_commission.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n @contract = Contract.find(params[:id])\n\n respond_to do |format|\n if @contract.update_attributes(params[:contract])\n format.html { redirect_to @contract.lead, notice: 'Contract was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @contract.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @employment_contract.update(employment_contract_params)\n format.html { redirect_to request_steps_path, notice: 'Request was successfully updated.' }\n format.json { render :show, status: :ok, location: @employment_contract }\n else\n format.html { render :edit }\n format.json { render json: @employment_contract.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bank_account_operation = BankAccountOperation.find(params[:id])\n\n respond_to do |format|\n if @bank_account_operation.update_attributes(params[:bank_account_operation])\n format.html { redirect_to @bank_account_operation, notice: 'Bank account operation was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bank_account_operation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @rule = Rule.find(params[:id])\n\t@account = Account.find(params[:account_id])\n params[:rule][:pocket_id] = params[:prefix][:pocket_id]\n respond_to do |format|\n if params[:commit].eql?('Cancel') || @rule.update_attributes(params[:rule])\n format.html { redirect_to(account_rules_url(@account)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @rule.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n unless @action.nil?\n log_action( action.name, @environment[:api_key] )\n\n @success.call( action ) if @success && @action\n @action = nil;\n end\n end",
"def update\n @cash_invoice.update cash_invoice_params\n render 'action'\n end",
"def update\n @accounting_office = AccountingOffice.find(params[:id])\n\n respond_to do |format|\n if @accounting_office.update_attributes(params[:accounting_office])\n format.html { redirect_to @accounting_office, notice: 'Accounting office was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @accounting_office.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # this action is not provided for partyroles\n end",
"def update\n @commission_fixing = CommissionFixing.find(params[:id])\n if @commission_fixing.update_attributes(params[:commission_fixing])\n render :json=>{:response=>\"success\"}\n else\n render :json=>failure1(@commission_fixing.errors)\n end \n end",
"def update\n @assert = Assert.find(params[:id])\n\n respond_to do |format|\n if @assert.update_attributes(params[:assert])\n format.html { redirect_to @assert, notice: 'Assert was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @assert.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @admin_accounting_bank_account = Admin::AccountingBankAccount.find(params[:id])\n\n respond_to do |format|\n if @admin_accounting_bank_account.update_attributes(params[:admin_accounting_bank_account])\n format.html { redirect_to admin_accounting_bank_accounts_url }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @admin_accounting_bank_account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(&block)\n validate_request()\n\n # Params includes all of the PATCH data at the top level along with other\n # other Rails-injected params like 'id', 'action', 'controller'. These\n # are harmless given no namespace collision and we're only interested in\n # the 'Operations' key for the actual patch data.\n #\n render(json: yield(self.safe_params()[:id], self.safe_params().to_hash()))\n end",
"def update\n @title = \"Update Operations\"\n @operation = Operation.find(params[:id])\n\n respond_to do |format|\n if @operation.update_attributes(params[:operation])\n flash[:notice] = 'Operation was successfully updated.'\n format.html { redirect_to(@operation) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @operation.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n redirect_unless_admin\n hide_left_menu\n\n @gift_card = GiftCard.find(params[:id])\n\n respond_to do |format|\n if @gift_card.update_attributes(params[:gift_card])\n format.html { redirect_to @gift_card, notice: 'Gift card was successfully updated.' }\n format.json { head :ok }\n else\n @type = SupplierAccountType.find_by_name(\"Vestidos Boutique\")\n @supplier_accounts = SupplierAccount.where(\"supplier_account_type_id = ?\", @type.id).approved\n \n format.html { render action: \"edit\" }\n format.json { render json: @gift_card.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @orderable_concept = OrderableConcept.find(params[:id])\n\n respond_to do |format|\n if @orderable_concept.update_attributes(params[:orderable_concept])\n format.html { redirect_to @orderable_concept, notice: 'Orderable concept was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @orderable_concept.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @obat = Obat.find(params[:id])\n\n user_being_acces, status = check_user_concurrence(@obat)\n unless status\n user_concurrence_blocked(user_being_acces, false)\n return\n end\n @id = params[:id]\n\n respond_to do |format|\n if @obat.update_attributes(params[:obat])\n format.html { redirect_to(:action => \"edit\", :id => @id, :notice => UPDATE_MSG) }\n format.xml { head :ok }\n else\n @cancel_url = request.fullpath+\"/edit\"\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @obat.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def activo_update\n respond_to do |format|\n activo = params[:laboratorio][:activo]\n id = params[:id]\n Laboratorio.where(id: id).update_all(activo: activo )\n msg = { :status => \"ok\", :message => \"Actualizado!\" }\n format.json { render :json => msg }\n end\n end",
"def update\n respond_to do |format|\n if @action_object.update(action_object_params)\n format.html { redirect_to action: 'index', notice: 'Objeto de Ação alterado com sucesso.'}\n format.json { render :show, status: :ok, location: @action_object }\n else\n format.html { render :edit }\n format.json { render json: @action_object.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @cashgifttype = Cashgifttype.find(params[:id])\n\n params.delete('action')\n params.delete('controller')\n params.delete('id')\n\n respond_to do |format|\n if @cashgifttype.update_attributes(params)\n format.html { redirect_to \"/events/#{@cashgifttype.event_id}/edit\", notice: 'Your Option Was Successfully Updated.' }\n format.mobile { redirect_to \"/events/#{@cashgifttype.event_id}/edit\", notice: 'Your Option Was Successfully Updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.mobile { render action: \"edit\" }\n format.json { render json: @cashgifttype.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @allowance = Allowance.find(params[:id])\n\n respond_to do |format|\n if @allowance.update_attributes(params[:allowance])\n format.html { redirect_to @allowance, notice: 'Allowance was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @allowance.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @act.update(act_params)\n format.html { redirect_to @act.play, notice: 'Act was successfully updated.' }\n format.json { respond_with_bip(@act) }\n else\n format.html { render :edit }\n format.json { respond_with_bip(@act) }\n end\n end\n end",
"def update\n respond_to do |format|\n if @operation.update(operation_params)\n format.html { redirect_to admin_operations_path, notice: 'Operation was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @operation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @assert = Assert.find(params[:id])\n\n respond_to do |format|\n if @assert.update_attributes(params[:assert])\n format.html { redirect_to @assert, notice: 'Assert was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @assert.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_initiative.update(api_v1_initiative_params)\n format.html { redirect_to @api_v1_initiative, notice: 'Initiative was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_initiative }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_initiative.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n set_action(:update)\n set_account_type\n validate_account_type!\n assign_params\n set_affiliate\n set_updated_by\n\n after_update\n account\n end",
"def update\n @contactaction = Contactaction.find(params[:id])\n\n respond_to do |format|\n if @contactaction.update_attributes(params[:contactaction])\n format.html { redirect_to @contactaction, :notice => 'Contactaction was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @contactaction.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\r\n @enrichment_act = EnrichmentAct.find(params[:id])\r\n\r\n respond_to do |format|\r\n if @enrichment_act.update_attributes(params[:enrichment_act])\r\n format.html { redirect_to @enrichment_act, notice: 'Enrichment act was successfully updated.' }\r\n format.json { head :no_content }\r\n else\r\n format.html { render action: \"edit\" }\r\n format.json { render json: @enrichment_act.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n @account = Account.find(params[:id])\n\n respond_to do |format|\n if @account.update_attributes(params[:account])\n format.html { redirect_to quick_launch_path, notice: 'Account was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_outcome.update(api_v1_outcome_params)\n format.html { redirect_to @api_v1_outcome, notice: 'Outcome was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_outcome }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_outcome.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @my_action.update(my_action_params)\n format.html { redirect_to @my_action, notice: 'My action was successfully updated.' }\n format.json { render :show, status: :ok, location: @my_action }\n else\n format.html { render :edit }\n format.json { render json: @my_action.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @action_file = ActionFile.find(params[:id])\n\n respond_to do |format|\n if @action_file.update_attributes(params[:action_file])\n format.html { redirect_to @action_file, notice: 'Action file was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @action_file.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to :json\n\n if @expense_claim.update(expense_claim_params)\n head :ok\n else\n render partial: 'expense_claim_key_data', layout: false, status: :ok, locals: { expense_claim: @expense_claim }\n end\n end",
"def update\n @dispatching = Dispatching.find(params[:id])\n workflow = @dispatching.workflow\n respond_to do |format|\n if params[:warranty] == \"进厂\"\n if @dispatching.update_attributes(params[:dispatching])\n workflow.update_attributes(:status => \"vehicle\")\n workflow.user_ids = params[:repairman_ids]\n workflow.users.each do |user|\n user.update_attributes(:status => \"busy\")\n end\n format.json { head :ok }\n else\n format.json { render :json => @dispatching.errors, :status => :unprocessable_entity }\n end\n elsif params[:warranty] == \"救援\"\n if @dispatching.update_attributes(params[:dispatching])\n workflow.update_attributes(:status => \"newpart\")\n format.json {head :ok}\n else\n format.json { render :json => @dispatching.errors, :status => :unprocessable_entity }\n end\n end\n end\n end",
"def update\n @withdrawal_request = WithdrawalRequest.find(params[:id])\n\n respond_to do |format|\n if @withdrawal_request.update_attributes(params[:withdrawal_request])\n format.html { redirect_to @withdrawal_request, notice: 'Withdrawal request was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @withdrawal_request.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_rest\n @answer_localized = AnswerLocalized.find(params[:id])\n\n respond_to do |format|\n if @answer_localized.update_attributes(params[:answer_localized])\n flash[:notice] = 'AnswerLocalized was successfully updated.'\n format.html { redirect_to(@answer_localized) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @answer_localized.errors, :status => :unprocessable_entity }\n end\n end\n end"
] | [
"0.6559312",
"0.6180124",
"0.61647856",
"0.61513054",
"0.61207145",
"0.60961133",
"0.6085956",
"0.60728",
"0.6069418",
"0.60690975",
"0.60685164",
"0.60589963",
"0.6055047",
"0.60198826",
"0.60186505",
"0.601076",
"0.5995826",
"0.5948335",
"0.59387714",
"0.59358305",
"0.59310555",
"0.59049815",
"0.5903878",
"0.589811",
"0.5887835",
"0.58694065",
"0.58649576",
"0.5850141",
"0.5844809",
"0.58367676",
"0.58345884",
"0.5833668",
"0.5826185",
"0.5823741",
"0.5801572",
"0.5798923",
"0.5797265",
"0.5788864",
"0.5783156",
"0.5781908",
"0.5781908",
"0.5781908",
"0.5781908",
"0.57750285",
"0.5773203",
"0.5772235",
"0.5770566",
"0.5767227",
"0.57671875",
"0.5766021",
"0.5763691",
"0.57618064",
"0.5755471",
"0.5752488",
"0.5745018",
"0.57418126",
"0.57302654",
"0.57294333",
"0.57249916",
"0.5723459",
"0.5717767",
"0.571706",
"0.57149714",
"0.57145816",
"0.5703619",
"0.57032955",
"0.5702712",
"0.5701439",
"0.5699805",
"0.5699015",
"0.5692849",
"0.5691585",
"0.5691169",
"0.56900704",
"0.568438",
"0.5684075",
"0.56833667",
"0.56818634",
"0.5679896",
"0.5679163",
"0.5678726",
"0.56783146",
"0.5677097",
"0.5674372",
"0.5672088",
"0.56701124",
"0.56695044",
"0.5665446",
"0.56646967",
"0.5663003",
"0.5658029",
"0.565143",
"0.5650514",
"0.5649716",
"0.5649517",
"0.5646221",
"0.5645901",
"0.56443226",
"0.56442034",
"0.5639679"
] | 0.69639516 | 0 |
DELETE /accounting_actions/1 DELETE /accounting_actions/1.json | def destroy
@accounting_action.destroy
respond_to do |format|
format.html { redirect_to accounting_actions_url, notice: 'Ação foi destruída com sucesso.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete\n ruta = \"/actions/#{action_id}\"\n client.delete(ruta)\n end",
"def delete(action, **args); end",
"def delete!( opts = {} )\n http_action :delete, nil, opts\n end",
"def api_delete(action, data)\n api_request(action, data, 'DELETE')\n end",
"def incident_delete(statuspage_id, incident_id)\n data = {}\n data['statuspage_id'] = statuspage_id\n data['incident_id'] = incident_id\n\n request :method => :post,\n :url => @url + 'incident/delete',\n :payload => data\n end",
"def destroy\n @accounting_entry.destroy\n respond_to do |format|\n format.html { redirect_to accounting_entries_url, notice: 'Se ha eliminado con exito!.' }\n format.json { head :no_content }\n end\n end",
"def delete\n request(:delete)\n end",
"def destroy\n @tredit_action = TreditAction.find(params[:id])\n @tredit_action.destroy\n\n respond_to do |format|\n format.html { redirect_to tredit_actions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tredit_action = TreditAction.find(params[:id])\n @tredit_action.destroy\n\n respond_to do |format|\n format.html { redirect_to tredit_actions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @accessory_act = AccessoryAct.find(params[:id])\n @accessory_act.destroy\n\n respond_to do |format|\n format.html { redirect_to accessory_acts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @payable_action = PayableAction.find(params[:id])\n @payable_action.destroy\n\n respond_to do |format|\n format.html { redirect_to(payable_actions_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @xaction = Xaction.find(params[:id])\n @xaction.destroy\n\n respond_to do |format|\n format.html { redirect_to xactions_url }\n format.json { head :no_content }\n end\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def delete()\n @api.do_request(\"DELETE\", get_base_api_path())\n end",
"def destroy\n @actum.destroy\n respond_to do |format|\n format.html { redirect_to acta_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @accounting_account.destroy\n respond_to do |format|\n format.html { redirect_to accounting_accounts_url, notice: 'La cuenta ha sido eliminada.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @gstr_advance_receipts = GstrAdvanceReceipt.find_by_id_and_company_id(params[:id], @company.id)\n @gstr_advance_receipts.delete_gstr_one_entry \n @gstr_advance_receipts.delete\n respond_to do |format|\n @gstr_advance_receipts.register_delete_action(request.remote_ip, @current_user, 'deleted')\n format.html { redirect_to(gstr_advance_receipts_url, :notice =>\"Gstr Advance Receipt has been succesfully deleted\") }\n format.xml {head :ok}\n \n end\n end",
"def delete\n response = WebPay.client.delete(path)\n response['deleted']\n end",
"def destroy\n @wallet_action.destroy\n respond_to do |format|\n format.html { redirect_to wallet_actions_url, notice: 'Wallet action was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @assert = Assert.find(params[:id])\n @assert.destroy\n\n respond_to do |format|\n format.html { redirect_to asserts_url }\n format.json { head :no_content }\n end\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n @api_v1_expense.destroy\n respond_to do |format|\n format.html { redirect_to api_v1_expenses_url, notice: 'Expense was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @expense = Expense.find(params[:id])\n @expense.destroy\n\n respond_to do |format|\n format.html { redirect_to account_statement_url(params[:account_id],params[:statement_id]) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @assert = Assert.find(params[:id])\n @assert.destroy\n\n respond_to do |format|\n format.html { redirect_to asserts_url }\n format.json { head :ok }\n end\n end",
"def destroy\n record = TaxRule.find(params[:id])\n record.trash\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @admin_accounting_bank_account = Admin::AccountingBankAccount.find(params[:id])\n @admin_accounting_bank_account.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_accounting_bank_accounts_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @next_action = NextAction.find(params[:id])\n @next_action.destroy\n\n respond_to do |format|\n format.html { redirect_to actions_url }\n format.json { head :no_content }\n end\n end",
"def delete!\n request! :delete\n end",
"def destroy\n @cta.destroy\n respond_to do |format|\n format.html { redirect_to cta_url }\n format.json { head :no_content }\n end\n end",
"def delete\n api(\"Delete\")\n end",
"def delete\n render json: Company.delete(params[\"id\"])\n end",
"def delete!\n resource = RESOURCE % { account_id: account.id, id: id }\n response = Request.new(account.client, :delete, resource).perform\n from_response(response.body[:data])\n end",
"def destroy\n @dosha_action.destroy\n respond_to do |format|\n format.html { redirect_to dosha_actions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @incrustation_tmp = @incrustation.dup\n @incrustation.destroy\n record_activity(@incrustation_tmp)\n respond_to do |format|\n format.html { redirect_to admin_incrustations_url, notice: 'Вставка была успешно удалена.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @accounting_entry.destroy\n\n authorize AccountingEntry\n \n respond_to do |format|\n format.html { redirect_to accounting_entries_url, notice: 'Accounting entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete(id:)\n id_check(:id, id)\n\n cf_delete(path: \"/organizations/#{org_id}/railguns/#{id}\")\n end",
"def destroy\n @actual_action_plan.destroy\n respond_to do |format|\n format.html { redirect_to actual_action_plans_url, notice: 'Actual action plan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @accident_item.destroy\n respond_to do |format|\n format.html { redirect_to accident_items_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cta = Cta.find(params[:id])\n @cta.destroy\n\n respond_to do |format|\n format.html { redirect_to ctas_url }\n format.json { head :no_content }\n end\n end",
"def delete_account\n @connection.request({\n :method => 'DELETE'\n }) \n end",
"def destroy\n Audit.find(params[:id]).destroy\n head :no_content\n end",
"def destroy\n @accreditation = Accreditation.find(params[:id])\n @accreditation.destroy\n\n respond_to do |format|\n format.html { redirect_to accreditations_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @activity_award_cfg.destroy\n respond_to do |format|\n format.html { redirect_to admin_activity_award_cfgs_url, notice: 'Activity award cfg was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Alien.delete(params[\"id\"])\n end",
"def destroy\n @action_deduct = ActionDeduct.find(params[:id])\n @action_deduct.destroy\n\n respond_to do |format|\n format.html { redirect_to(action_deducts_url) }\n format.xml { head :ok }\n format.json { head :ok }\n end\n end",
"def destroy\n @withdrawal_request = WithdrawalRequest.find(params[:id])\n @withdrawal_request.destroy\n\n respond_to do |format|\n format.html { redirect_to withdrawal_requests_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @action_name = ActionName.find(params[:id])\n @action_name.destroy\n\n respond_to do |format|\n format.html { redirect_to action_names_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cashbox.destroy\n respond_to do |format|\n format.html { redirect_to cashbox_index_url }\n format.json { head :no_content }\n end\n end",
"def cfa_delete\n Rails.logger.info_log.info \" I,[#{Time.now.strftime(\"%Y-%m-%d %H:%M:%S %Z\")}]\" \"INFO -- : Entered in cfa titles cfa_delete method\"\n begin\n id=params[\"format\"] \n cfa=RestClient.delete $api_service+'/cfa_titles/'+id\n rescue =>e\n Rails.logger.custom_log.error { \"#{e} Cfa controller delete method\" }\n end\n redirect_to action: \"index\"\n end",
"def destroy\n authenticate_user!\n authorize! :index, @user, :message => 'Not authorized as an administrator.'\n \n @campaign = Campaign.find(params[:id])\n \n @campaign.pledges.destroy_all\n @campaign.key_policy_makers.destroy_all\n @campaign.beneficiaries.destroy_all\n @campaign.updates.destroy_all\n \n @campaign.destroy\n\n respond_to do |format|\n format.html { redirect_to campaigns_url }\n format.json { head :no_content }\n end\n end",
"def delete_resource_action(type, id = nil, data = nil)\n api_resource(type, id, \"Detaching\") do |resource|\n delete_resource_main_action(type, resource, data)\n end\n end",
"def destroy\n @marketing_action = MarketingAction.find(params[:id])\n @marketing_action.destroy\n\n respond_to do |format|\n format.html { redirect_to :action=> 'index' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bank_reconciliations = AccountingBankReconciliations.find(params[:id])\n @bank_reconciliations.destroy\n\n respond_to do |format|\n format.html { redirect_to(accounting_bank_reconciliations_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @record = Asset.find(params[:id])\n @record.trash\n respond_to do |format| \n format.json { head :no_content }\n end\n end",
"def destroy\n authorize @incoming_service_tax\n\n @incoming_service_tax.destroy\n respond_to do |format|\n format.html { redirect_to incoming_service_taxes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cashflow = Cashflow.find(params[:id])\n @cashflow.destroy\n\n respond_to do |format|\n format.html { redirect_to cashflows_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n #binding.pry\n @balance = Balance.find(params[:id])\n @balance.destroy\n respond_to do |format|\n format.html { redirect_to balances_url }\n format.json { head :no_content }\n end\n end",
"def delete\n url = prefix + \"delete\" + id_param\n return response(url)\n end",
"def destroy\n respond_with @expense.destroy, status: 204\n end",
"def destroy\n @journal_debit.destroy\n respond_to do |format|\n format.html { redirect_to journal_debits_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n head :forbidden\n # @action = Action.find(params[:id])\n # @action.destroy\n\n # head :no_content\n end",
"def destroy\n @adhoc_deliverable = Deliverable.find(params[:id])\n #delete adhoc deliverable from database\n @adhoc_deliverable.destroy\n\n respond_to do |format|\n format.html { redirect_to adhoc_deliverables_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @actionable.destroy\n respond_to do |format|\n format.html { redirect_to actionables_url, notice: 'Actionable was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @early_access_request.destroy\n respond_to do |format|\n format.html { redirect_to early_access_requests_url, notice: 'Anfrage wurde gelöscht.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @account_payable = AccountPayable.find(params[:id])\n @account_payable.destroy\n\n respond_to do |format|\n format.html { redirect_to account_payables_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @inc_stable_account.destroy\n respond_to do |format|\n format.html { redirect_to inc_stable_accounts_url, notice: 'Inc stable account was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def deleteRequest\n\n end",
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def destroy\n @stats_money_transaction = Stats::MoneyTransaction.find(params[:id])\n @stats_money_transaction.destroy\n\n respond_to do |format|\n format.html { redirect_to stats_money_transactions_url }\n format.json { head :ok }\n end\n end",
"def destroy_rest\n @item_usage = ItemUsage.find(params[:id])\n @item_usage.destroy\n\n respond_to do |format|\n format.html { redirect_to(item_usages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @status_ativ = StatusAtiv.find(params[:id])\n @status_ativ.destroy\n\n respond_to do |format|\n format.html { redirect_to status_ativs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @accion.destroy\n respond_to do |format|\n format.html { redirect_to accions_url }\n format.json { head :no_content }\n end\n end",
"def delete path\n make_request(path, \"delete\", {})\n end",
"def destroy\n @incident.destroy\n respond_to do |format|\n format.html { redirect_to incidents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @incident.destroy\n respond_to do |format|\n format.html { redirect_to incidents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bank_account_operation = BankAccountOperation.find(params[:id])\n @bank_account_operation.destroy\n\n respond_to do |format|\n format.html { redirect_to bank_account_operations_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @buy_action.destroy\n respond_to do |format|\n format.html { redirect_to admin_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contact_action = ContactAction.find(params[:id])\n @contact_action.destroy\n\n respond_to do |format|\n format.html { redirect_to contact_actions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @acct_transaction.destroy\n respond_to do |format|\n format.html { redirect_to acct_transactions_url, notice: 'Acct transaction was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission_type = AdmissionType.find(params[:id])\n @admission_type.destroy\n\n respond_to do |format|\n format.html { redirect_to admission_types_url }\n format.json { head :no_content }\n end\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def destroy\n @bill = Bill.find(params[:id])\n # TODO: \"un-updateEnergyGoals\" related to this bill\n @bill.destroy\n\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @payable = Payable.find(params[:id])\n # Updating GlAccount\n # accountsPayableAmt = 0\n # @payable.payable_accounts.each do |payable_account|\n # CommonActions.update_gl_accounts(payable_account.gl_account.gl_account_title, 'decrement',payable_account.payable_account_amount,@payable.id )\n # accountsPayableAmt += payable_account.payable_account_amount\n # end\n # CommonActions.update_gl_accounts('ACCOUNTS PAYABLE', 'decrement',accountsPayableAmt, @payable.id )\n @payable.destroy\n\n\n\n respond_to do |format|\n format.html { redirect_to payables_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @action_routine.destroy\n respond_to do |format|\n format.html { redirect_to [project, exaction, @hp_condition], notice: 'Action routine was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ipc_all_ac.destroy\n respond_to do |format|\n format.html { redirect_to ipc_all_acs_url }\n format.json { head :no_content }\n end\n end",
"def delete_accounts\n end",
"def destroy\n @contactaction = Contactaction.find(params[:id])\n @contactaction.destroy\n\n respond_to do |format|\n format.html { redirect_to contactactions_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @annex = Annex.find(params[:id])\n @annex.destroy\n\n respond_to do |format|\n format.html { redirect_to annexes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @operations_check = OperationsCheck.find(params[:id])\n @operations_check.destroy\n\n respond_to do |format|\n format.html { redirect_to operations_checks_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @expense.destroy\n\n respond_to do |format|\n format.html { redirect_to expenses_url }\n format.json { head :ok }\n end\n end",
"def delete(action = 'Objective Action')\n click_on(SELECTOR_MAPPING[action]['Delete']['button'][$janus::ELEMENT])\n end",
"def destroy\n @expensesbasis.destroy\n respond_to do |format|\n format.html { redirect_to [@post, @expensesbasis], notice: 'Expensesbase was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete\n\n end",
"def destroy\n @withdrawal = Withdrawal.find(params[:id])\n @withdrawal.destroy\n\n respond_to do |format|\n format.html { redirect_to withdrawals_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @atr = Atr.find(params[:id])\n @atr.destroy\n\n respond_to do |format|\n format.html { redirect_to atrs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @purchase.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end"
] | [
"0.7379961",
"0.68510187",
"0.6750856",
"0.67353356",
"0.6643555",
"0.66296476",
"0.66043776",
"0.6600791",
"0.6600791",
"0.6593604",
"0.6579225",
"0.65561295",
"0.65194035",
"0.6510677",
"0.6510677",
"0.6510677",
"0.6510677",
"0.6507833",
"0.6506663",
"0.6498255",
"0.6485366",
"0.64751315",
"0.6467553",
"0.64636797",
"0.64523673",
"0.6450761",
"0.6449979",
"0.64369684",
"0.64318854",
"0.6422498",
"0.6420185",
"0.64199805",
"0.6405413",
"0.6401721",
"0.6399879",
"0.63954836",
"0.6368272",
"0.63648385",
"0.6354078",
"0.63465554",
"0.63455856",
"0.63422126",
"0.63353395",
"0.6325712",
"0.6318715",
"0.63176465",
"0.6315307",
"0.631484",
"0.63110995",
"0.630867",
"0.63036174",
"0.6301468",
"0.63006",
"0.62874866",
"0.62871516",
"0.62829715",
"0.6281755",
"0.6279566",
"0.62689626",
"0.6265584",
"0.62645507",
"0.62624186",
"0.62506247",
"0.6248141",
"0.62458885",
"0.6240162",
"0.62396693",
"0.623948",
"0.6238212",
"0.6237332",
"0.62349856",
"0.62337005",
"0.62306106",
"0.6230212",
"0.6230194",
"0.62256706",
"0.6224876",
"0.6224876",
"0.62200177",
"0.62182534",
"0.6217433",
"0.621554",
"0.62153524",
"0.6214614",
"0.6214614",
"0.6214473",
"0.62139416",
"0.6208879",
"0.62081236",
"0.620808",
"0.6204644",
"0.62046105",
"0.6203025",
"0.6201732",
"0.6197662",
"0.61968416",
"0.619561",
"0.61941165",
"0.61940813",
"0.61937284"
] | 0.72398055 | 1 |
Use callbacks to share common setup or constraints between actions. | def set_accounting_action
@accounting_action = AccountingAction.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def accounting_action_params
params.require(:accounting_action).permit(:codigo, :descricao, :exercise_id)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def valid_params_request?; end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def filtering_params\n params.permit(:email)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def list_params\n params.permit(:name)\n end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def url_whitelist; end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def backend_user_params\n params.permit!\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] | [
"0.6980629",
"0.67819995",
"0.67467666",
"0.67419875",
"0.67347664",
"0.65928614",
"0.6504013",
"0.6498014",
"0.64819515",
"0.64797956",
"0.64562726",
"0.64400834",
"0.6380117",
"0.6377456",
"0.63656694",
"0.6320543",
"0.63002014",
"0.62997127",
"0.629425",
"0.6293866",
"0.62909746",
"0.62904227",
"0.62837297",
"0.6240993",
"0.6239739",
"0.6217764",
"0.6214983",
"0.62112504",
"0.6194765",
"0.6178",
"0.61755055",
"0.61729854",
"0.61636627",
"0.6153461",
"0.6151674",
"0.61478525",
"0.6122671",
"0.61188513",
"0.61075556",
"0.6105721",
"0.6092412",
"0.6081011",
"0.6071054",
"0.6064436",
"0.6022111",
"0.6018135",
"0.60151577",
"0.60108894",
"0.60070235",
"0.60070235",
"0.6000806",
"0.6000464",
"0.5998811",
"0.59926987",
"0.5992257",
"0.5991173",
"0.5980311",
"0.59660876",
"0.59596545",
"0.5959415",
"0.59589994",
"0.5957478",
"0.5953214",
"0.5952233",
"0.5944033",
"0.59396756",
"0.59396756",
"0.59386414",
"0.59345603",
"0.5931261",
"0.5926345",
"0.5925795",
"0.59174526",
"0.59108645",
"0.5909469",
"0.5908263",
"0.59053195",
"0.58980685",
"0.5897738",
"0.589657",
"0.5895971",
"0.58942044",
"0.5892847",
"0.588742",
"0.58834344",
"0.5880024",
"0.58739793",
"0.5868253",
"0.5867907",
"0.58670515",
"0.58668053",
"0.5865756",
"0.5863549",
"0.5863236",
"0.5862728",
"0.5861283",
"0.58591247",
"0.5855159",
"0.5854291",
"0.58512247",
"0.58498096"
] | 0.0 | -1 |
GET /facultads GET /facultads.json | def index
@facultads = Facultad.all
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @ads = Ad.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ads }\n end\n end",
"def index\n @ads = Ad.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ads }\n end\n end",
"def index\n @facultades = Facultad.all\n end",
"def index\n @faculties = Faculty.all\n json_response(@faculties)\n end",
"def index\n @attendees = Attendees.all\n render json: @attendees\n end",
"def show\n respond_to do |format|\n format.html\n format.json { render json: { advertisements: @advertisements } }\n end\n end",
"def index\n @appeals = @conference.appeals\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @appeals }\n end\n end",
"def index\n @leads = Lead.upcoming\n .includes(:updates, :agents, :agent)\n .order(created_at: :desc)\n .page(params[:page])\n .per(50)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @leads }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def index\n @ads = @org.ads\n end",
"def index\n @finance_leads = FinanceLead.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @finance_leads }\n end\n end",
"def index\n @admittings = Admitting.all\n render json: @admittings\n end",
"def index\n #get the featured campaigns\n @campaigns = Campaign.where({ featured: true }).order(\"created_at DESC\").limit(8)\n #create array of objects where we display each campaign's id, name, goal and image_url\n campaigns_hash_array = @campaigns.collect{|campaign| {\"campaign_id\"=> campaign.id, \"campaign_name\" => campaign.name, \"campaign_goal\" => campaign.goal_cents/100, \"campaign_image_url\" => campaign.getimageurl(campaign.image) }}\n if(campaigns_hash_array != nil)\n render json: campaigns_hash_array\n else\n render json: no_featured_campaigns_error, :status => 404\n end\n end",
"def index\n @ads = Ad.all.ultimos\n end",
"def index\n @attendees = Attendee.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @attendees }\n end\n end",
"def show\n @fortune = Fortune.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @fortune }\n end\n end",
"def index\n @facultades = Facultade.all\n end",
"def show\n json_response(@faculty)\n end",
"def index\n @advertises = current_user.advertises.page(params[:page])\n respond_to do |format|\n format.html\n format.json\n end\n end",
"def index\n @ads = Ad.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @ads }\n format.json { render :json => @ads }\n end\n end",
"def index\n @leads = Lead.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @leads }\n end\n end",
"def show\n render json: @admitting\n end",
"def index\n @facults = Facult.all\n end",
"def index\n @advertisements = Advertisement.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @advertisements }\n end\n end",
"def index\n @advertisements = Advertisement.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @advertisements }\n end\n end",
"def index\n @campaigns = Campaign.all\n render json: @campaigns\n end",
"def index\n @campaigns = site.campaigns.by_campaign_and_day.all\n render :json => @campaigns\n end",
"def index\n respond_with Ad.all \n end",
"def index \n fans = Fan.all \n render json: fans \n end",
"def show\n @ad_contact = AdContact.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_contact }\n end\n end",
"def index\n # @faculties = Faculty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: Oj.dump(@faculties, mode: :compat) }\n end\n end",
"def show\n @ad_post = AdPost.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_post }\n end\n end",
"def index\n @flights = Flight.all\n render json: @flights\n end",
"def show\n render json: @faculty\n end",
"def index\n @adversaires = Adversaire.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @adversaires }\n end\n end",
"def show\n @oferta_academica = OfertaAcademica.find(params[:id])\n\n render json: @oferta_academica\n end",
"def index\n @departments = Department.all\n respond_to do |format|\n format.json{ render json: @departments}\n end\n end",
"def show\n render json: @diet, status: 200, root: true\n end",
"def index\n @funds = Fund.all\n\n render json: @funds\n end",
"def show\n render json: @advert\n end",
"def index\n @announcements = Announcement.all\n render json: @announcements, include: [:member => {only: [:first_name, :last_name, :id]}]\n end",
"def index\n @sales_ads = SalesAd.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sales_ads }\n end\n end",
"def index\n @departamentos = Departamento.all\n\n render json: @departamentos\n end",
"def index\n @facebook_ads = FacebookAd.all\n end",
"def index\n @adults = Adult.all\n end",
"def show\n render json: @campaign\n end",
"def show\n render json: @educations\n end",
"def index\n contacteds = @business.contacteds\n \n render json: contacteds\n end",
"def index\n @facebookads = Facebookad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @diciplinas = Diciplina.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @diciplinas }\n end\n end",
"def index\n @campaigns = Campaign.where(:live => true)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @campaigns }\n end\n end",
"def show\n @home_indices_ad = Home::Indices::Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @home_indices_ad }\n end\n end",
"def show\n @aadt = Aadt.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @aadt }\n end\n end",
"def index\n @agencyfeeds = AgencyFeed.all\n\n render :index, status: :ok\n end",
"def index\n @fbposts = Fbpost.all\n render json: @fbposts\n end",
"def show\n @advocacy = Advocacy.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advocacy }\n end\n end",
"def index\n puts session[:_csrf_token]\n @departments = Department.all\n render json: @departments, status: :ok\n end",
"def index\n @announcements = Feature.for_announcements.published.page params[:announcements]\n @activities = PublicActivity::Activity.order(\"created_at desc\").page params[:activities]\n \n \n # @all_features = Feature.homepage_list\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @features }\n format.js\n end\n end",
"def consulta\n fiesta = Fiesta.all\n render json: fiesta\n end",
"def index\n @fundamental_alliance_leader_votes = Fundamental::AllianceLeaderVote.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @fundamental_alliance_leader_votes }\n end\n end",
"def show\n @finance_lead = FinanceLead.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @finance_lead }\n end\n end",
"def index\n @facilities = Facility.all\n respond_with @facilities\n end",
"def index\n @ads = Ad.all \n end",
"def show\n @advertisement = Advertisement.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advertisement }\n end\n end",
"def index\n @lead_entries = LeadEntry.where(:lead_id => params[:lead_id]).paginate(:page => params[:page])\n\n respond_to do |format|\n format.html { render action: 'index' }\n format.json {\n render :json => {\n :amount => @lead_entries.length,\n :success => true,\n :html => (render_to_string partial: 'list.html.haml')\n }\n }\n end\n end",
"def flights\n trip = Trip.where('id = ?', params[:id]).take\n if !trip.nil\n respond_with( trip.flights )\n else\n render :json => { error: 404 }, :status => 404\n end\n end",
"def index\n @campaigns = Campaign.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @campaigns }\n end\n end",
"def show\n @attendee = Attendees.find(params[:id])\n render json: @attendee\n end",
"def index\n head 404\n # @api_v1_followings = Api::V1::Following.all\n\n # render json: @api_v1_followings\n end",
"def index\n @filials = Filial.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @filials }\n end\n end",
"def index\n @cargapp_ads = CargappAd.all\n\n @result = []\n @cargapp_ads.each do |cargapp_ad|\n @obj = {\n id: cargapp_ad.id,\n name: cargapp_ad.name,\n price: cargapp_ad.price,\n description: cargapp_ad.description,\n body: cargapp_ad.body,\n image: cargapp_ad.image.attached? ? url_for(cargapp_ad.image) : nil,\n url: cargapp_ad.url,\n media: cargapp_ad.media.attached? ? url_for(cargapp_ad.media) : nil,\n have_discoun: cargapp_ad.have_discoun,\n is_percentage: cargapp_ad.is_percentage,\n discoun: cargapp_ad.discoun,\n active: cargapp_ad.active,\n user_id: cargapp_ad.user_id,\n created_at: cargapp_ad.created_at,\n updated_at: cargapp_ad.updated_at\n }\n @result << @obj\n end\n render json: @result\n end",
"def index\n @advertises = Advertise.all\n render 'index', formats: 'json', handlers: 'jbuilder'\n end",
"def index\n @absences = Absence.where(\"member_id = ?\",params[:member_id]).order(\"start_date DESC\").page(params[:page]).per(7)\n @member = Member.find(params[:member_id])\n \n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @absences }\n end\n end",
"def index\n @pacientes = Pacientes.all\n render json: @pacientes\n end",
"def show\n @audience = Audience.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @audience }\n end\n end",
"def new\n @fortune = Fortune.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @fortune }\n end\n end",
"def index\n @referral_contacts = @user.referralContact.page(params[:page]).per(params[:per])\n\n render json: @referral_contacts\n end",
"def show\n @faafacility = Faafacility.find(params[:id])\n @remarks = @faafacility.remarks\n @faarunways = @faafacility.faarunways\n @faaschedules = @faafacility.faaschedules\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @faafacility }\n end\n end",
"def index\n @flaws = Flaw.order(\"date DESC, created_at DESC\").page( params[:page] ).per(10)\n \n @flaw = Flaw.new\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @flaws }\n end\n end",
"def show\n render json: @adopter\n end",
"def index\n render json: @fiestas\n end",
"def show\n render json: @fund\n end",
"def index\n @scheduled_facilities = ScheduledFacility.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @scheduled_facilities }\n end\n end",
"def show\n @adversaire = Adversaire.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @adversaire }\n end\n end",
"def index\n @flights = Flight.all\n\n respond_to do |format|\n format.html \n format.json { render json: @flights, :include => [:airplane, :reservations, :users, :seats] }\n end\n end",
"def index\n @educations = Education.all\n render json: @educations\n end",
"def show\n @departure = Departure.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @departure }\n end\n end",
"def show\n @create_classified_ad = CreateClassifiedAd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @create_classified_ad }\n end\n end",
"def index\n @ways_of_admissions = WaysOfAdmission.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @ways_of_admissions }\n end\n end",
"def index\n @adjs = Adj.all\n end",
"def index\n @deportes = Deporte.all\n render json: @deportes, status: :ok \n @deportes = Deporte.paginate(:page => params[:page])\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @ad }\n format.json \n end\n end",
"def faculties\n @faculties = Faculty.where(university_id: params[:university_id]).order(:name)\n @courses = []\n respond_to do |format|\n format.json { render json: @faculties }\n end\n end"
] | [
"0.66060245",
"0.6595312",
"0.6508431",
"0.6376407",
"0.6260962",
"0.6250794",
"0.6207674",
"0.6201946",
"0.619315",
"0.619315",
"0.619315",
"0.6184212",
"0.61769783",
"0.6137919",
"0.611267",
"0.61098826",
"0.6099774",
"0.60900086",
"0.6081118",
"0.6073202",
"0.60653996",
"0.60634923",
"0.6058092",
"0.6053742",
"0.6040355",
"0.6036092",
"0.6036092",
"0.5990728",
"0.5988449",
"0.596899",
"0.59551996",
"0.5945199",
"0.5925848",
"0.59250003",
"0.5921917",
"0.5902474",
"0.59016407",
"0.58961016",
"0.5894069",
"0.5885866",
"0.5883649",
"0.5879571",
"0.58664674",
"0.58645535",
"0.5864189",
"0.5863201",
"0.58598256",
"0.5858642",
"0.58544147",
"0.5851817",
"0.58412796",
"0.58369005",
"0.58369005",
"0.58369005",
"0.58369005",
"0.58369005",
"0.583499",
"0.5831292",
"0.582965",
"0.5825685",
"0.5815835",
"0.5810526",
"0.5804208",
"0.5798306",
"0.57938164",
"0.5793157",
"0.5778355",
"0.5762534",
"0.5760998",
"0.57604337",
"0.57603854",
"0.5754712",
"0.5754595",
"0.57498014",
"0.5743609",
"0.57312614",
"0.5729849",
"0.5727371",
"0.5713905",
"0.5709461",
"0.5708123",
"0.5706912",
"0.56964004",
"0.5695404",
"0.5689441",
"0.5685806",
"0.56784487",
"0.56776094",
"0.56707954",
"0.5667743",
"0.5667485",
"0.5661727",
"0.5660214",
"0.56586564",
"0.5642644",
"0.563977",
"0.563815",
"0.56371427",
"0.5636493",
"0.5634909"
] | 0.72913426 | 0 |
GET /facultads/1 GET /facultads/1.json | def show
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @facultads = Facultad.all\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad }\n end\n end",
"def index\n @ads = Ad.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ads }\n end\n end",
"def index\n @ads = Ad.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ads }\n end\n end",
"def show\n @fortune = Fortune.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @fortune }\n end\n end",
"def show\n @ad_contact = AdContact.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_contact }\n end\n end",
"def show\n @home_indices_ad = Home::Indices::Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @home_indices_ad }\n end\n end",
"def show\n @ad_post = AdPost.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_post }\n end\n end",
"def index\n @facultades = Facultad.all\n end",
"def show\n respond_to do |format|\n format.html\n format.json { render json: { advertisements: @advertisements } }\n end\n end",
"def show\n @oferta_academica = OfertaAcademica.find(params[:id])\n\n render json: @oferta_academica\n end",
"def show\n render json: Festival.build_for(params[:id]).to_json\n end",
"def show\n @create_classified_ad = CreateClassifiedAd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @create_classified_ad }\n end\n end",
"def show\n @advocacy = Advocacy.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advocacy }\n end\n end",
"def show\n @audience = Audience.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @audience }\n end\n end",
"def show\n @advertisement = Advertisement.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advertisement }\n end\n end",
"def index\n @faculties = Faculty.all\n json_response(@faculties)\n end",
"def index\n @ads = @org.ads\n end",
"def show\n render json: @advert\n end",
"def show\n @aadt = Aadt.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @aadt }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @ad }\n format.json \n end\n end",
"def show\n render json: @campaign\n end",
"def show\n json_response(@faculty)\n end",
"def index\n #get the featured campaigns\n @campaigns = Campaign.where({ featured: true }).order(\"created_at DESC\").limit(8)\n #create array of objects where we display each campaign's id, name, goal and image_url\n campaigns_hash_array = @campaigns.collect{|campaign| {\"campaign_id\"=> campaign.id, \"campaign_name\" => campaign.name, \"campaign_goal\" => campaign.goal_cents/100, \"campaign_image_url\" => campaign.getimageurl(campaign.image) }}\n if(campaigns_hash_array != nil)\n render json: campaigns_hash_array\n else\n render json: no_featured_campaigns_error, :status => 404\n end\n end",
"def show\n @ad_type = AdType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_type }\n end\n end",
"def show\n @fund = Fund.friendly.find(params[:id])\n\n render json: @fund\n end",
"def index\n @appeals = @conference.appeals\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @appeals }\n end\n end",
"def show\n @facility_total = FacilityTotal.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @facility_total }\n end\n end",
"def show\n @finance_lead = FinanceLead.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @finance_lead }\n end\n end",
"def index\n @ads = Ad.all.ultimos\n end",
"def show\n @adversaire = Adversaire.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @adversaire }\n end\n end",
"def show\n @advert = Advert.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advert }\n end\n end",
"def index\n @ads = Ad.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @ads }\n format.json { render :json => @ads }\n end\n end",
"def show\n @institution_ad = InstitutionAd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @institution_ad }\n end\n end",
"def show\n @ad_unit = AdUnit.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_unit }\n end\n end",
"def index\n @advertises = current_user.advertises.page(params[:page])\n respond_to do |format|\n format.html\n format.json\n end\n end",
"def show\n @obj = {\n id: @cargapp_ad.id,\n name: @cargapp_ad.name,\n price: @cargapp_ad.price,\n description: @cargapp_ad.description,\n body: @cargapp_ad.body,\n image: @cargapp_ad.image.attached? ? url_for(@cargapp_ad.image) : nil,\n url: @cargapp_ad.url,\n media: @cargapp_ad.media.attached? ? url_for(@cargapp_ad.media) : nil,\n have_discoun: @cargapp_ad.have_discoun,\n is_percentage: @cargapp_ad.is_percentage,\n discoun: @cargapp_ad.discoun,\n active: cargapp_ad.active,\n user_id: @cargapp_ad.user_id,\n created_at: @cargapp_ad.created_at,\n updated_at: @cargapp_ad.updated_at\n } \n render json: @obj\n end",
"def index\n @campaigns = Campaign.all\n render json: @campaigns\n end",
"def show\n @budgetcategory = Budgetcategory.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @budgetcategory }\n end\n end",
"def show\n render json: @admitting\n end",
"def show\n @campaign = Campaign.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @campaign }\n end\n end",
"def show\n load_budget\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @budget }\n end\n end",
"def show\n @advertisment = Advertisment.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advertisment }\n end\n end",
"def new\n @ad = Ad.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @ad }\n end\n end",
"def new\n @ad = Ad.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @ad }\n end\n end",
"def show\n render json: @faculty\n end",
"def show\n @campaign = Campaign.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @campaign }\n end\n end",
"def show\n @budget = Budget.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n # format.json { render json: @budget }\n end\n end",
"def show\n @sales_ad = SalesAd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @sales_ad }\n end\n end",
"def show\n @futbolada = Futbolada.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @futbolada }\n end\n end",
"def show\n render json: @diet, status: 200, root: true\n end",
"def show\n @ad = Ad.find(params[:id])\n end",
"def show\n @ad = Ad.find(params[:id])\n end",
"def index\n @facults = Facult.all\n end",
"def show\n @adv = Advantage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @adv }\n end\n end",
"def show\n @advert = Advert.find(params[:id])\n @vcounter = ViewsCounter.counter('Advert', params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @advert }\n end\n end",
"def index\n @facultades = Facultade.all\n end",
"def show\n @faafacility = Faafacility.find(params[:id])\n @remarks = @faafacility.remarks\n @faarunways = @faafacility.faarunways\n @faaschedules = @faafacility.faaschedules\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @faafacility }\n end\n end",
"def show\n @ad_tag = AdTag.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ad_tag }\n end\n end",
"def index\n @admittings = Admitting.all\n render json: @admittings\n end",
"def show\n #@klass_fee = KlassFee.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @klass_fee }\n end\n end",
"def show\n @apuesta_detail = ApuestaDetail.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @apuesta_detail }\n end\n end",
"def new\n @fortune = Fortune.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @fortune }\n end\n end",
"def index\n @campaigns = site.campaigns.by_campaign_and_day.all\n render :json => @campaigns\n end",
"def show\n @flight = Flight.find(params[:id])\n render json: @flight\n end",
"def show\n @creative = Creative.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @creative }\n end\n end",
"def show\n @vkontakte_campaign = VkontakteCampaign.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @vkontakte_campaign }\n end\n end",
"def show\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n format.html \n end\n end",
"def index\n @cargapp_ads = CargappAd.all\n\n @result = []\n @cargapp_ads.each do |cargapp_ad|\n @obj = {\n id: cargapp_ad.id,\n name: cargapp_ad.name,\n price: cargapp_ad.price,\n description: cargapp_ad.description,\n body: cargapp_ad.body,\n image: cargapp_ad.image.attached? ? url_for(cargapp_ad.image) : nil,\n url: cargapp_ad.url,\n media: cargapp_ad.media.attached? ? url_for(cargapp_ad.media) : nil,\n have_discoun: cargapp_ad.have_discoun,\n is_percentage: cargapp_ad.is_percentage,\n discoun: cargapp_ad.discoun,\n active: cargapp_ad.active,\n user_id: cargapp_ad.user_id,\n created_at: cargapp_ad.created_at,\n updated_at: cargapp_ad.updated_at\n }\n @result << @obj\n end\n render json: @result\n end",
"def index\n @advertisements = Advertisement.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @advertisements }\n end\n end",
"def index\n @advertisements = Advertisement.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @advertisements }\n end\n end",
"def show\n @humanidades1 = Humanidades1.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @humanidades1 }\n end\n end",
"def index\n @sales_ads = SalesAd.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sales_ads }\n end\n end",
"def show\n @humanidades3 = Humanidades3.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @humanidades3 }\n end\n end",
"def index\n @finance_leads = FinanceLead.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @finance_leads }\n end\n end",
"def show\n @departure = Departure.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @departure }\n end\n end",
"def show\n render json: @fund\n end",
"def show\n @respuesta = Respuesta.find(params[:id])\n\n render json: @respuesta\n end",
"def details\n @daily_deal = DailyDeal.find(params[:id])\n respond_to do |format|\n format.json do\n render with_api_version\n end\n end\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def index\n @ads = Ad.all\n end",
"def show\n @announcement = Announcement.find(params[:id])\n render json:@announcement\n end",
"def index\n respond_with Ad.all \n end",
"def show\n @affiliate_link = AffiliateLink.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @affiliate_link }\n end\n end",
"def show\n @fetmeeting = Fetmeeting.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @fetmeeting }\n end\n end",
"def show\n @consulta = Consulta.find(params[:id])\n\n render json: @consulta\n end",
"def show\n @admin_agency = Admin::Agency.where(:id => params[:id]).includes(:pages)[0]\n \n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @admin_agency }\n end\n end",
"def new\n @faafacility = Faafacility.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @faafacility }\n end\n end",
"def index\n @attendees = Attendees.all\n render json: @attendees\n end",
"def show\n @periodo_academico = PeriodoAcademico.find(params[:id])\n\n render json: @periodo_academico\n end",
"def show\n @acd = Acd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @acd }\n end\n end",
"def index\n @campaigns = Campaign.where(:live => true)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @campaigns }\n end\n end",
"def consulta\n fiesta = Fiesta.all\n render json: fiesta\n end",
"def index\n@magazine = Magazine.find_by_id(params[:magazine_id])\n@ads = @magazine.ads\nend",
"def show\n @purchasing_ad = PurchasingAd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @purchasing_ad }\n end\n end",
"def show\n\t\t@ad = Ad.includes({:ad_group => :campaign}, :ad_type).where(\"campaigns.account_id = ?\", @auth_user.account_id).find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # show.html.erb\n\t\t\tformat.xml { render :xml => @ad }\n\t\tend\n\tend"
] | [
"0.7070108",
"0.6730687",
"0.6730687",
"0.6730687",
"0.6633119",
"0.6617508",
"0.6455344",
"0.6397225",
"0.6388993",
"0.63712746",
"0.63526756",
"0.6316881",
"0.6288255",
"0.62807703",
"0.6263859",
"0.6259303",
"0.6213569",
"0.62095803",
"0.62015563",
"0.6193738",
"0.61843807",
"0.6179307",
"0.6169518",
"0.61681116",
"0.6165999",
"0.6153196",
"0.6140508",
"0.61316687",
"0.6118781",
"0.6113234",
"0.6109441",
"0.61035174",
"0.6103128",
"0.61029124",
"0.6084001",
"0.6070321",
"0.60674345",
"0.606639",
"0.60607475",
"0.6049429",
"0.60473686",
"0.6040775",
"0.6035416",
"0.60269994",
"0.6023667",
"0.6018149",
"0.6018149",
"0.60175025",
"0.6013233",
"0.6009269",
"0.60064834",
"0.6002655",
"0.59997636",
"0.59942794",
"0.59942794",
"0.5993381",
"0.59875447",
"0.59842896",
"0.5983369",
"0.59819365",
"0.5979892",
"0.5974913",
"0.5970217",
"0.5967886",
"0.5964875",
"0.59636205",
"0.59600633",
"0.5959803",
"0.59578586",
"0.5951504",
"0.5949787",
"0.5943426",
"0.5943426",
"0.5942147",
"0.5937005",
"0.59354275",
"0.5931025",
"0.5929191",
"0.59120154",
"0.59101206",
"0.5907043",
"0.5894997",
"0.5894997",
"0.5894997",
"0.5894997",
"0.5894997",
"0.589462",
"0.5894372",
"0.58911407",
"0.5889039",
"0.5888617",
"0.58827835",
"0.58814925",
"0.5879861",
"0.5879581",
"0.58754075",
"0.5873037",
"0.58702344",
"0.586832",
"0.5867366",
"0.5865856"
] | 0.0 | -1 |
POST /facultads POST /facultads.json | def create
@facultad = Facultad.new(facultad_params)
respond_to do |format|
if @facultad.save
format.html { redirect_to @facultad, notice: 'Facultad was successfully created.' }
format.json { render :show, status: :created, location: @facultad }
else
format.html { render :new }
format.json { render json: @facultad.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create\n @facultad = Facultad.new(facultad_params)\n\n respond_to do |format|\n if @facultad.save\n format.html { redirect_to facultade_path(@facultad), notice: \"Facultad fue creada correctamente.\" }\n format.json { render :show, status: :created, location: @facultad }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @facultad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n fix_tokenized_input_params\n @ad = @org.ads.build(ad_params)\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to [@ad.org, @ad], notice: 'Ad was successfully created.' }\n format.json { render :show, status: :created, location: [@ad.org, @ad] }\n else\n format.html { render :new }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(ad_params)\n\n if @ad.save\n render :show, status: :created, location: @ad\n else\n render json: @ad.errors, status: :unprocessable_entity\n end\n end",
"def create\n @ad = current_user.ads.new(ad_params)\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: 'Ad was successfully created.' }\n format.json { render :show, status: :created, location: @ad }\n else\n format.html { render :new }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(ad_params)\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: 'Ad was successfully created.' }\n format.json { render :show, status: :created, location: @ad }\n else\n format.html { render :new }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(params[:ad])\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: 'Ad was successfully created.' }\n format.json { render json: @ad, status: :created, location: @ad }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @admeafit = Admeafit.new(admeafit_params)\n\n respond_to do |format|\n if @admeafit.save\n format.html { redirect_to @admeafit, notice: 'Admeafit was successfully created.' }\n format.json { render :show, status: :created, location: @admeafit }\n else\n format.html { render :new }\n format.json { render json: @admeafit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t@ad = Ad.new(ad_params)\n\[email protected] = current_user\n\trespond_to do |format|\n\t if @ad.save\n\t\tformat.html { redirect_to ad_path(@ad), notice: 'Ad was successfully created.' }\n\t\tformat.json { render :show, status: :created, location: @ad }\n\t else\n\t\tformat.html { render :new }\n\t\tformat.json { render json: @ad.errors, status: :unprocessable_entity }\n\t end\n\tend\n end",
"def create\n @ad = Ad.new(ad_params)\n @ad.user = current_user\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: 'Ad was successfully created.' }\n format.json { render :show, status: :created, location: @ad }\n else\n format.html { render :new }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @faculties = Faculty.create!(faculty_params)\n json_response(@faculties, :created)\n end",
"def createAd\n @nfo = params[:ad][:nfo]\n params[:ad].delete :nfo\n @ad = Ad.new(params[:ad])\n @ad.account_id = session[:account_id]\n respond_to do |format| #if the javascript response is empty, this may never run\n if @ad.save\n format.js\n end\n end\n end",
"def create\n @ad_post = AdPost.new(params[:ad_post])\n\n respond_to do |format|\n if @ad_post.save\n format.html { redirect_to @ad_post, notice: 'Ad post was successfully created.' }\n format.json { render json: @ad_post, status: :created, location: @ad_post }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad_post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @facebookad = Facebookad.new(facebookad_params)\n\n respond_to do |format|\n if @facebookad.save\n format.html { redirect_to @facebookad, notice: 'Facebookad was successfully created.' }\n format.json { render :show, status: :created, location: @facebookad }\n else\n format.html { render :new }\n format.json { render json: @facebookad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisement = current_user.ads.new(advertisement_params)\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to app_advertisements_url, notice: 'Advertisement was successfully created.' }\n format.json { render :show, status: :created, location: @advertisement }\n else\n format.html { render :new }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advetiser = Advetiser.new(advetiser_params)\n\n respond_to do |format|\n if @advetiser.save\n format.html { redirect_to @advetiser, notice: 'Advetiser was successfully created.' }\n format.json { render :show, status: :created, location: @advetiser }\n else\n format.html { render :new }\n format.json { render json: @advetiser.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n passenger = Passenger.new(:name => params[:name], :contact_number => params[:contact_number], :nationality => params[:nationality], :meal_pref => params[:meal_pref])\n passenger.save\n render :json => passenger\n end",
"def create\n @facultade = Facultade.new(facultade_params)\n\n respond_to do |format|\n if @facultade.save\n format.html { redirect_to @facultade, notice: 'Facultade was successfully created.' }\n format.json { render :show, status: :created, location: @facultade }\n else\n format.html { render :new }\n format.json { render json: @facultade.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @facult = Facult.new(facult_params)\n\n respond_to do |format|\n if @facult.save\n format.html { redirect_to @facult, notice: 'Facult was successfully created.' }\n format.json { render action: 'show', status: :created, location: @facult }\n else\n format.html { render action: 'new' }\n format.json { render json: @facult.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @facultads = Facultad.all\n end",
"def create\n @adult = Adult.new(adult_params)\n\n respond_to do |format|\n if @adult.save\n format.html { redirect_to @adult, notice: 'Adult was successfully created.' }\n format.json { render :show, status: :created, location: @adult }\n else\n format.html { render :new }\n format.json { render json: @adult.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @article = Article.new(article_params)\n\n json_parse = JSON.parse(@article.advertisement)\n ad_hash = json_parse.map { |data|\n ApplicationController.helpers.a8_parse(data)\n }\n ad_hash_json = ActiveSupport::JSON.encode(ad_hash)\n @article[:advertisement] = ad_hash_json\n\n respond_to do |format|\n if @article.save\n format.html { redirect_to @article, notice: 'Article was successfully created.' }\n format.json { render :show, status: :created, location: @article }\n else\n format.html { render :new }\n format.json { render json: @article.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(params[:ad])\n @ad.user_id=current_user.id\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: 'Ad was successfully created.' }\n format.json { render json: @ad, status: :created, location: @ad }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @admitting = Admitting.new(admitting_params)\n\n if @admitting.save\n render json: @admitting, status: :created, location: @admitting\n else\n render json: @admitting.errors, status: :unprocessable_entity\n end\n end",
"def create\n @adscripcion = Adscripcion.new(adscripcion_params)\n\n respond_to do |format|\n if @adscripcion.save\n format.html { redirect_to @adscripcion, notice: 'Adscripcion was successfully created.' }\n format.json { render :show, status: :created, location: @adscripcion }\n else\n format.html { render :new }\n format.json { render json: @adscripcion.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad_plan = AdPlan.new(ad_plan_params)\n\n respond_to do |format|\n if @ad_plan.save\n format.html { redirect_to @ad_plan, notice: 'Ad plan was successfully created.' }\n format.json { render :show, status: :created, location: @ad_plan }\n else\n format.html { render :new }\n format.json { render json: @ad_plan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @adherent = Adherent.new(adherent_params)\n\n respond_to do |format|\n if @adherent.save\n format.html { redirect_to @adherent, notice: 'Adherent was successfully created.' }\n format.json { render :show, status: :created, location: @adherent }\n else\n format.html { render :new }\n format.json { render json: @adherent.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @ad_post = AdPost.new\n @ad_post.users.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @ad_post }\n end\n end",
"def create\n @diet = Diet.new(diet_params)\n @diet.user = @current_user\n\n if @diet.save\n render json: @diet, status: 201, location: @diet, root: true\n else\n render json: @diet.errors, status: 422\n end\n end",
"def create\n @ad = current_advertiser.ads.new(params[:ad])\n respond_to do |format|\n if @ad.save\n format.html { redirect_to(@ad, :notice => 'Ad was successfully created.') }\n format.xml { render :xml => @ad, :status => :created, :location => @ad }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @ad.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(ad_params)\n\n respond_to do |format|\n if @ad.save\n flash[:notice] = :ad_was_successfully_created.l\n format.html { redirect_to ad_url(@ad) }\n else\n format.html { render :action => \"new\" }\n end\n end\n end",
"def create\n @facebook_ad = FacebookAd.new(facebook_ad_params)\n @facebook_ad.facebook_connected_account = @facebook_connected_account\n\n respond_to do |format|\n if @facebook_ad.save\n format.html { redirect_to @facebook_ad, notice: 'Facebook ad was successfully created.' }\n format.json { render :show, status: :created, location: @facebook_ad }\n else\n format.html { render :new }\n format.json { render json: @facebook_ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lead = Lead.new(lead_params)\n @lead.campaign_id = @campaign.id\n\n respond_to do |format|\n if @lead.save\n format.html { redirect_to thanks_path, notice: 'Your subscription has been successfully completed.' }\n format.json { render :show, status: :created, location: @lead }\n else\n format.html { render :new }\n format.json { render json: @lead.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = current_user.ads.new(params[:ad])\n\n respond_to do |format|\n if @ad.save\n flash[:notice] = 'Ad was successfully created.'\n format.html { redirect_to([current_user,@ad]) }\n format.xml { render :xml => @ad, :status => :created, :location => @ad }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @ad.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisement = Advertisement.new(params[:advertisement])\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render json: @advertisement, status: :created, location: @advertisement }\n else\n format.html { render action: \"new\" }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @fact = @cat.facts.create!({ fact: api_request })\n if @fact.save\n render json: @fact\n else\n render error: { message: \"Não foi possível criar esse fato para este gatinho! :(\" }, status: 400\n end\n end",
"def create\n @advertisement = Advertisement.new(advertisement_params)\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to events_pictures_step_1_path(:advertisement_id => @advertisement.id), notice: 'Advertisement was successfully created.' }\n format.json { render :show, status: :created, location: @advertisement }\n else\n format.html { render :new }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n # @advertisement = Advertisement.new(params[:advertisement])\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render json: @advertisement, status: :created, location: @advertisement }\n else\n format.html { render action: \"new\", notice: 'Advertisement was NOT successfully created.' }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @afp = Afp.new(afp_params)\n\n respond_to do |format|\n if @afp.save\n format.html { redirect_to @afp, notice: 'Afp was successfully created.' }\n format.json { render :show, status: :created, location: @afp }\n else\n format.html { render :new }\n format.json { render json: @afp.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @adopter = Adopter.new(adopter_params)\n\n if @adopter.save\n render json: @adopter, status: :created, location: @adopter\n else\n render json: @adopter.errors, status: :unprocessable_entity\n end\n end",
"def create\n @home_indices_ad = Home::Indices::Ad.new(params[:home_indices_ad])\n\n respond_to do |format|\n if @home_indices_ad.save\n format.html { redirect_to @home_indices_ad, notice: 'Ad was successfully created.' }\n format.json { render json: @home_indices_ad, status: :created, location: @home_indices_ad }\n else\n format.html { render action: \"new\" }\n format.json { render json: @home_indices_ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lead = Lead.new(lead_params)\n\n if @lead.save\n render :show, status: :created, location: @lead\n else\n render json: @lead.errors, status: :unprocessable_entity\n end\n end",
"def create\n @ad_contact = AdContact.new(params[:ad_contact])\n\n respond_to do |format|\n if @ad_contact.save\n format.html { redirect_to @ad_contact, notice: 'Ad contact was successfully created.' }\n format.json { render json: @ad_contact, status: :created, location: @ad_contact }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad_contact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @cargapp_ad = CargappAd.new(cargapp_ad_params)\n\n if @cargapp_ad.save\n @obj = {\n id: @cargapp_ad.id,\n name: @cargapp_ad.name,\n price: @cargapp_ad.price,\n description: @cargapp_ad.description,\n body: @cargapp_ad.body,\n image: @cargapp_ad.image.attached? ? url_for(@cargapp_ad.image) : nil,\n url: @cargapp_ad.url,\n media: @cargapp_ad.media.attached? ? url_for(@cargapp_ad.media) : nil,\n have_discoun: @cargapp_ad.have_discoun,\n is_percentage: @cargapp_ad.is_percentage,\n discoun: @cargapp_ad.discoun,\n active: @cargapp_ad.active,\n user_id: @cargapp_ad.user_id,\n created_at: @cargapp_ad.created_at,\n updated_at: @cargapp_ad.updated_at\n }\n render json: @obj, status: :created, location: @cargapp_ad\n else\n render json: @cargapp_ad.errors, status: :unprocessable_entity\n end\n end",
"def create\n @advertisement_campaign = AdvertisementCampaign.new(advertisement_campaign_params)\n\n respond_to do |format|\n if @advertisement_campaign.save\n format.html { redirect_to @advertisement_campaign, notice: 'Advertisement campaign was successfully created.' }\n format.json { render action: 'show', status: :created, location: @advertisement_campaign }\n else\n format.html { render action: 'new' }\n format.json { render json: @advertisement_campaign.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @agency = Agency.new(agency_params)\n\n if @agency.save\n render json: @agency, status: :created, location: @agency\n else\n render json: @agency.errors, status: :unprocessable_entity\n end\n end",
"def create\n @falta = Falta.new(falta_params)\n\n respond_to do |format|\n if @falta.save\n format.html { redirect_to @falta, notice: \"Falta was successfully created.\" }\n format.json { render :show, status: :created, location: @falta }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @falta.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = current_user.ads.build(ad_params)\n @ad.delivery_currency = ad_params[\"price_currency\"]\n\n respond_to do |format|\n if @ad.save\n format.html { redirect_to @ad, notice: \"Ad was successfully created.\" }\n format.json { render :show, status: :created, location: @ad }\n else\n format.html { render :new }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create \n cartoon_ad = CartoonAd.create(cartoon_ad_params)\n render json: cartoon_ad\n end",
"def create\n @ad_banner = AdBanner.new(ad_banner_params)\n\n respond_to do |format|\n if @ad_banner.save\n format.html { redirect_to @ad_banner, notice: 'Ad banner was successfully created.' }\n format.json { render action: 'show', status: :created, location: @ad_banner }\n else\n format.html { render action: 'new' }\n format.json { render json: @ad_banner.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @ad = Ad.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @ad }\n end\n end",
"def new\n @ad = Ad.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @ad }\n end\n end",
"def create\n @oferta_academica = OfertaAcademica.new(params[:oferta_academica])\n\n if @oferta_academica.save\n render json: @oferta_academica, status: :created, location: @oferta_academica\n else\n render json: @oferta_academica.errors, status: :unprocessable_entity\n end\n end",
"def create\n @aadt = Aadt.new(params[:aadt])\n\n respond_to do |format|\n if @aadt.save\n format.html { redirect_to @aadt, notice: 'Aadt was successfully created.' }\n format.json { render json: @aadt, status: :created, location: @aadt }\n else\n format.html { render action: \"new\" }\n format.json { render json: @aadt.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(params[:ad])\n\n respond_to do |format|\n if @ad.save\n flash[:notice] = 'Ad was successfully created.'.l\n format.html { redirect_to ad_url(@ad) }\n format.xml { head :created, :location => ad_url(@ad) }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @ad.errors.to_xml }\n end\n end\n end",
"def create\n @adults_howyouknowu = AdultsHowyouknowu.new(params[:adults_howyouknowu])\n\n respond_to do |format|\n if @adults_howyouknowu.save\n format.html { redirect_to(@adults_howyouknowu, :notice => 'Adults howyouknowu was successfully created.') }\n format.xml { render :xml => @adults_howyouknowu, :status => :created, :location => @adults_howyouknowu }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @adults_howyouknowu.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @postac = Postac.new(postac_params)\n\n respond_to do |format|\n if @postac.save\n format.html { redirect_to @postac, notice: 'Postac was successfully created.' }\n format.json { render :show, status: :created, location: @postac }\n else\n format.html { render :new }\n format.json { render json: @postac.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(params[:ad])\n @ad.account_id = session[:account_id]\n respond_to do |format|\n if @ad.save\n format.html { redirect_to(@ad, :notice => 'Ad was successfully created.') }\n format.xml { render :xml => @ad, :status => :created, :location => @ad }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @ad.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @agencyfeed = AgencyFeed.create! agencyfeed_params\n render :show, status: :created\n end",
"def create\n @respuesta = Respuesta.new(params[:respuesta])\n\n if @respuesta.save\n render json: @respuesta, status: :created, location: @respuesta\n else\n render json: @respuesta.errors, status: :unprocessable_entity\n end\n end",
"def create\n @adss = Adss.new(adss_params)\n\n respond_to do |format|\n if @adss.save\n format.html { redirect_to @adss }\n format.json { render :show, status: :created, location: @adss }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @adss.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n advertisement = params[:advertisement]\n advertisement[\"ad_type\"] = \"video\"\n advertisement[\"user_id\"] = current_user.id\n\n if advertisement[\"content_link\"].start_with? \"http\", \"www\"\n advertisement[\"content_link\"].match /[?|&]v=([^&]*)/\n advertisement[\"content_link\"] = $1\n end\n\n @advertisement = Advertisement.new(advertisement)\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to my_advertisements_path, notice: 'Advertisement was successfully created.' }\n format.json { render json: @advertisement, status: :created, location: @advertisement }\n else\n format.html { render action: \"new\" }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advert = Advert.new(params[:advert])\n\n respond_to do |format|\n if @advert.save\n format.html { redirect_to @advert, notice: 'Advert was successfully created.' }\n format.json { render json: @advert, status: :created, location: @advert }\n else\n format.html { render action: \"new\" }\n format.json { render json: @advert.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisement = current_user.advertisements.new(advertisement_params)\n @advertisement.status = INACTIVE\n respond_to do |format|\n if @advertisement.save\n \n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render :show, status: :created, location: @advertisement }\n message = \"Heyy new advertisement: #{@advertisement.title} is added by #{current_user.user_profile.name}\"\n User.get_customer_dealer(message)\n else\n format.html { render :new }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @federation = Federation.new(federation_params)\n\n respond_to do |format|\n if @federation.save\n format.html { redirect_to @federation, notice: 'Federation was successfully created.' }\n format.json { render :show, status: :created, location: @federation }\n format.xml { render :xml => @federation, :status => :created, :location => @federation }\n else\n format.html { render :new }\n format.json { render json: @federation.errors, status: :unprocessable_entity }\n format.xml { render :xml => @federation.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @fund = Fund.new(fund_params)\n\n if @fund.save\n render json: @fund, status: :created, location: @fund\n else\n render json: @fund.errors, status: :unprocessable_entity\n end\n end",
"def create\n @create_classified_ad = CreateClassifiedAd.new(params[:create_classified_ad])\n @create_classified_ad.user_id = current_user.id\n respond_to do |format|\n if @create_classified_ad.save\n format.html { redirect_to @create_classified_ad, notice: 'Create classified ad was successfully created.' }\n format.json { render json: @create_classified_ad, status: :created, location: @create_classified_ad }\n else\n format.html { render action: \"new\" }\n format.json { render json: @create_classified_ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advert = Advert.new(advert_params)\n\n respond_to do |format|\n if @advert.save\n format.html { redirect_to @advert, notice: 'Advert was successfully created.' }\n format.json { render :show, status: :created, location: @advert }\n else\n format.html { render :new }\n format.json { render json: @advert.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #@adhub = Adhub.new(adhub_params)\n @adhub = current_user.adhubs.build(adhub_params)\n\n respond_to do |format|\n if @adhub.save\n format.html { redirect_to @adhub, notice: \"Advertisement was successfully created.\" }\n format.json { render :show, status: :created, location: @adhub }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @adhub.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisement = current_user.advertisements.build(advertisement_params)\n @advertisement.state = \"waiting\"\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render :show, status: :created, location: @advertisement }\n else\n format.html { render :new }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @adversaire = Adversaire.new(params[:adversaire])\n @equipe = Equipe.find(params[:equipe_id])\n\n respond_to do |format|\n if @adversaire.save\n format.html { redirect_to @equipe, :notice => 'Adversaire was successfully created.' }\n format.json { render :json => @adversaire, :status => :created, :location => @equipe }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @adversaire.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @ad = Ad.new(ad_params)\n\n if @ad.save\n redirect_to @ad\n else\n render 'new'\n end\n end",
"def create\n @adcategory = Adcategory.new(adcategory_params)\n\n respond_to do |format|\n if @adcategory.save\n format.html { redirect_to @adcategory, notice: 'Adcategory was successfully created.' }\n format.json { render action: 'show', status: :created, location: @adcategory }\n else\n format.html { render action: 'new' }\n format.json { render json: @adcategory.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @attendee = Attendee.new(attendee_params)\n\n respond_to do |format|\n if @attendee.save\n format.json { render json: @attendee.to_json, status: :created }\n else\n format.json { render json: @attendee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @engagement_attendee = EngagementAttendee.new(engagement_params)\n if @engagement_attendee.save\n render :show, status: :created, location: api_v1_engagement_url(@engagement_attendee)\n else\n render json: @engagement_attendee.errors, status: :unprocessable_entity\n end\n end",
"def create\n @departamento = Departamento.new(departamento_params)\n\n if @departamento.save\n render json: @departamento, status: :created, location: @departamento\n else\n render json: @departamento.errors, status: :unprocessable_entity\n end\n end",
"def new_lead\n @lead = Lead.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @lead }\n end\n end",
"def create\n @adj = Adj.new(adj_params)\n\n respond_to do |format|\n if @adj.save\n format.html { redirect_to @adj, notice: 'Adj was successfully created.' }\n format.json { render :show, status: :created, location: @adj }\n else\n format.html { render :new }\n format.json { render json: @adj.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad_unit = AdUnit.new(params[:ad_unit])\n\n respond_to do |format|\n if @ad_unit.save\n format.html { redirect_to @ad_unit, notice: 'Ad unit was successfully created.' }\n format.json { render json: @ad_unit, status: :created, location: @ad_unit }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad_unit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @campaign = Campaign.new(campaign_params)\n\n if @campaign.save\n render json: @campaign\n else\n render json: @campaign.errors, status: :unprocessable_entity\n end\n end",
"def create\n @survey = Survey.find(params[:survey_id])\n emoji = params[:emoji]\n mood = params[:mood]\n @feeling = Feeling.new(mood: mood, emoji: emoji)\n @survey.feelings << @feeling\n\n if @feeling.save\n render :ok, json: @feeling\n else\n @errors = @feelings.error.full_messages\n render json: {message: @errors}, status: :unprocessable_entity\n end\n\n if !@survey\n render json: {message: [\"Survey is Required!\"] }, status: :unprocessable_entity\n end\n end",
"def create\n @fullassessment = Fullassessment.new(fullassessment_params)\n respond_to do |format|\n if @fullassessment.save\n format.json { render json: @fullassessment }\n else\n format.html { render :new }\n format.json { render json: @fullassessment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad_holder = AdHolder.new(ad_holder_params)\n\n respond_to do |format|\n if @ad_holder.save\n format.html { redirect_to @ad_holder, notice: 'Ad holder was successfully created.' }\n format.json { render :show, status: :created, location: @ad_holder }\n else\n format.html { render :new }\n format.json { render json: @ad_holder.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ad_type = AdType.new(params[:ad_type])\n\n respond_to do |format|\n if @ad_type.save\n format.html { redirect_to @ad_type, notice: 'Ad type was successfully created.' }\n format.json { render json: @ad_type, status: :created, location: @ad_type }\n else\n format.html { render action: \"new\" }\n format.json { render json: @ad_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @adult_children_trait = AdultChildrenTrait.new(adult_children_trait_params)\n\n respond_to do |format|\n if @adult_children_trait.save\n format.html { redirect_to @adult_children_trait, notice: 'Adult children trait was successfully created.' }\n format.json { render :show, status: :created, location: @adult_children_trait }\n else\n format.html { render :new }\n format.json { render json: @adult_children_trait.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisment = Advertisment.new(params[:advertisment])\n\n respond_to do |format|\n if @advertisment.save\n format.html { redirect_to @advertisment, notice: 'Advertisment was successfully created.' }\n format.json { render json: @advertisment, status: :created, location: @advertisment }\n else\n format.html { render action: \"new\" }\n format.json { render json: @advertisment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lead = current_user.leads.build(params[:lead])\n\n respond_to do |format|\n if @lead.save\n format.html { redirect_to @lead, :notice => 'Lead was successfully created.' }\n format.json { render :json => @lead, :status => :created, :location => @lead }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @lead.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @ad_account = AdAccount.new(ad_account_params)\n @ad_account.user = current_user\n\n respond_to do |format|\n if @ad_account.save\n format.html { redirect_to @ad_account, notice: 'Ad account was successfully created.' }\n format.json { render :show, status: :created, location: @ad_account }\n else\n format.html { render :new }\n format.json { render json: @ad_account.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @appeal = Appeal.new(params[:appeal])\n @appeal.conference = @conference\n\n respond_to do |format|\n if @appeal.save\n format.html { redirect_to [@conference, @appeal], notice: 'Appeal was successfully created.' }\n format.json { render json: @appeal, status: :created, location: @appeal }\n else\n format.html { render layout: \"application_no_nav\",action: \"new\" }\n format.json { render json: @appeal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @flight = Flight.new(params[:flight])\n\n if @flight.save\n render json: @flight, status: :created, location: @flight\n else\n render json: @flight.errors, status: :unprocessable_entity\n end\n end",
"def create\n @advertisement = Advertisement.new(advertisement_params)\n @advertisement.user = current_user\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render :show, status: :created, location: @advertisement }\n else\n format.html { render :new }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lead = Lead.new(lead_params)\n @lead.ip = request.remote_ip\n respond_to do |format|\n if @lead.save\n firebase = Firebase::Client.new(ENV['FIREBASE_URL'], ENV['FIREBASE_SECRET'])\n response = firebase.push(\"leads\", { id: @lead.id, name: @lead.name, last_name: @lead.last_name, email: @lead.email, ip: @lead.ip, created_at: @lead.created_at.to_s })\n format.html { redirect_to content_path, notice: 'Parabéns! Esse é nosso conteúdo exclusivo.' }\n else\n if Lead.where(email:@lead.email).exists?\n format.html { redirect_to content_path, notice: 'Esse email já está cadastrado!' }\n else\n format.html { render :new }\n end\n end\n end\n end",
"def create\n@magazine = Magazine.find_by_id(params[:magazine_id])\n@ad = @magazine.ads.build(ad_params)\nrespond_to do |format|\nif @ad.save\nformat.html { redirect_to magazine_ad_path(@magazine, @ad), notice:\n'Ad was successfully updated.' }\nformat.json { render :show, status: :created, location: @ad }\nelse\nformat.html { render :new }\nformat.json { render json: @ad.errors, status: :unprocessable_entity }\nend\nend\nend",
"def create\n @attendee = Attendee.new(attendee_params)\n\n respond_to do |format|\n if @attendee.save\n format.html { redirect_to @attendee, :notice => 'Attendee was successfully created.' }\n format.json { render :json => @attendee, :status => :created, :location => @attendee }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @attendee.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @advertisement = Advertisement.new(params[:advertisement])\n \n @advertisement.uploaded_file = params[:advertisement][:image]\n @advertisement.event_id_id = params[:advertisement][:event_id_id]\n @advertisement.link = params[:advertisement][:link]\n\n respond_to do |format|\n if @advertisement.save\n format.html { redirect_to @advertisement, notice: 'Advertisement was successfully created.' }\n format.json { render json: @advertisement, status: :created, location: @advertisement }\n else\n format.html { render action: \"new\" }\n format.json { render json: @advertisement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @admission = Admission.new(admission_params)\n\n respond_to do |format|\n if @admission.save\n format.html { redirect_to @admission, notice: 'Admission was successfully created.' }\n format.json { render :show, status: :created, location: @admission }\n else\n format.html { render :new }\n format.json { render json: @admission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @facture = Facture.new(facture_params)\n\n respond_to do |format|\n if @facture.save\n format.html { redirect_to add_ref_path(@facture), notice: 'La facture a bien été créée.'} \n format.json { render :add_ref, status: :created, location: @facture }\n else\n format.html { render :new }\n format.json { render json: @facture.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @fortune = Fortune.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @fortune }\n end\n end",
"def create\n @audience = Audience.new(params[:audience])\n\n respond_to do |format|\n if @audience.save\n format.html { redirect_to @audience, notice: 'Audience was successfully created.' }\n format.json { render json: @audience, status: :created, location: @audience }\n else\n format.html { render action: \"new\" }\n format.json { render json: @audience.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @faafacility = Faafacility.new(params[:faafacility])\n\n respond_to do |format|\n if @faafacility.save\n format.html { redirect_to @faafacility, notice: 'Faafacility was successfully created.' }\n format.json { render json: @faafacility, status: :created, location: @faafacility }\n else\n format.html { render action: \"new\" }\n format.json { render json: @faafacility.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @desafio = Desafio.new(desafio_params)\n\n respond_to do |format|\n if @desafio.save\n format.html { redirect_to @desafio, notice: 'Desafio was successfully created.' }\n format.json { render :show, status: :created, location: @desafio }\n else\n format.html { render :new }\n format.json { render json: @desafio.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.65177464",
"0.631646",
"0.6312829",
"0.62912595",
"0.6236799",
"0.6200291",
"0.6165413",
"0.60846835",
"0.60358524",
"0.6008719",
"0.60035914",
"0.5994915",
"0.5886182",
"0.58849823",
"0.58768916",
"0.5853262",
"0.58451164",
"0.5837635",
"0.5834386",
"0.5811399",
"0.5804717",
"0.5803102",
"0.58027595",
"0.5780161",
"0.5762145",
"0.57479966",
"0.5714523",
"0.57018214",
"0.570121",
"0.568846",
"0.5673279",
"0.5671152",
"0.56508344",
"0.5625939",
"0.5618466",
"0.56144613",
"0.5606811",
"0.5605612",
"0.55961955",
"0.5589746",
"0.5580955",
"0.55666304",
"0.55529684",
"0.5541653",
"0.5536748",
"0.5517633",
"0.5516143",
"0.55067945",
"0.54893",
"0.5484054",
"0.5484054",
"0.54712737",
"0.5464089",
"0.54639",
"0.54488456",
"0.54473567",
"0.54472506",
"0.5443498",
"0.5443223",
"0.5440472",
"0.54369557",
"0.54305756",
"0.5427557",
"0.54268134",
"0.5422077",
"0.5421151",
"0.5416027",
"0.54153097",
"0.54127455",
"0.5408759",
"0.54053175",
"0.5400197",
"0.5397198",
"0.53968096",
"0.53957194",
"0.5386484",
"0.5375781",
"0.5372461",
"0.5361562",
"0.5360136",
"0.5354988",
"0.5354202",
"0.53507113",
"0.53502387",
"0.5350086",
"0.53353965",
"0.5332739",
"0.5329082",
"0.53217316",
"0.5320384",
"0.5318027",
"0.5316406",
"0.53109944",
"0.53100306",
"0.5308974",
"0.53070104",
"0.5298662",
"0.5296199",
"0.52957296",
"0.52910835"
] | 0.6584896 | 0 |
PATCH/PUT /facultads/1 PATCH/PUT /facultads/1.json | def update
respond_to do |format|
if @facultad.update(facultad_params)
format.html { redirect_to @facultad, notice: 'Facultad was successfully updated.' }
format.json { render :show, status: :ok, location: @facultad }
else
format.html { render :edit }
format.json { render json: @facultad.errors, status: :unprocessable_entity }
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update\n respond_to do |format|\n if @facult.update(facult_params)\n format.html { redirect_to @facult, notice: 'Facult was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @facult.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @facultad.update(facultad_params)\n format.html { redirect_to facultade_path(@facultad), notice: \"Facultad fue actualizada correctamente.\" }\n format.json { render :show, status: :ok, location: @facultad }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @facultad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @facultade.update(facultade_params)\n format.html { redirect_to @facultade, notice: 'Facultade was successfully updated.' }\n format.json { render :show, status: :ok, location: @facultade }\n else\n format.html { render :edit }\n format.json { render json: @facultade.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fortune = Fortune.find(params[:id])\n\n respond_to do |format|\n if @fortune.update_attributes(params[:fortune])\n format.html { redirect_to @fortune, notice: 'Piosenka pozytywnie zaktualizowana.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fortune.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @appraisal_fee.update(appraisal_fee_params)\n format.html { redirect_to appraisal_fees_path, notice: 'Appraisal fee was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @appraisal_fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fact.update(fact_params)\n format.html { redirect_to :back }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @festival = Festival.find(params[:id])\n\n respond_to do |format|\n if @festival.update_attributes(params[:festival])\n format.html { redirect_to @festival, notice: 'Festival was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @festival.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @admeafit.update(admeafit_params)\n format.html { redirect_to @admeafit, notice: 'Admeafit was successfully updated.' }\n format.json { render :show, status: :ok, location: @admeafit }\n else\n format.html { render :edit }\n format.json { render json: @admeafit.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fascicle.update(fascicle_params)\n format.html { redirect_to @fascicle, notice: 'Fascicle was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fascicle.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fact.update(fact_params)\n format.html { redirect_to @fact, notice: 'Fact was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fact = Fact.find(fact_params)\n\n respond_to do |format|\n if @fact.update_attributes(fact_params)\n format.html { redirect_to @fact, notice: 'Fact was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n if @ad.update_attributes(params[:ad])\n format.html { redirect_to @ad, notice: 'Ad was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ad = Ad.find(params[:id])\n\n respond_to do |format|\n if @ad.update_attributes(params[:ad])\n format.html { redirect_to @ad, notice: 'Ad was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @falta.update(falta_params)\n format.html { redirect_to @falta, notice: \"Falta was successfully updated.\" }\n format.json { render :show, status: :ok, location: @falta }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @falta.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @oferta_academica = OfertaAcademica.find(params[:id])\n\n if @oferta_academica.update(params[:oferta_academica])\n head :no_content\n else\n render json: @oferta_academica.errors, status: :unprocessable_entity\n end\n end",
"def update\n @agency = Agency.find(params[:id])\n\n if @agency.update(agency_params)\n #head :no_content\n render json: @agency, status: :accepted, location: @agency #sera? status accepted? \n else\n render json: @agency.errors, status: :unprocessable_entity\n end\n end",
"def update\n @factoid = Factoid.find(params[:id])\n\n respond_to do |format|\n if @factoid.update_attributes(params[:factoid])\n format.html { redirect_to @factoid, notice: 'Factoid was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @factoid.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @aff.update(aff_params)\n format.html { redirect_to @aff, notice: 'Aff was successfully updated.' }\n format.json { render :show, status: :ok, location: @aff }\n else\n format.html { render :edit }\n format.json { render json: @aff.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @flight = Flight.find(params[:id])\n\n if @flight.update(params[:flight])\n head :no_content\n else\n render json: @flight.errors, status: :unprocessable_entity\n end\n end",
"def update\n\n @foaf.interests.clear\n\n if(foaf_params.has_key?(:interests_attributes))\n interest_ids = foaf_params[:interests_attributes].split(\",\").map { |s| s.to_i }\n interest_ids.each do |i|\n @foaf.interests << Interest.find(i)\n #@foaf.update(Interest.find(i))\n end\n \n end\n\n respond_to do |format|\n if @foaf.update(name: foaf_params[:name], work: foaf_params[:work], \n slug: foaf_params[:slug], birthday: foaf_params[:birthday])\n format.html { redirect_to @foaf, notice: 'FOAF was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @foaf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @frat.update(frat_params)\n format.html { redirect_to @frat, notice: 'Frat was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @frat.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @persona = Persona.find(params[:id])\n \n respond_to do |format|\n if @persona.update_attributes(params[:persona])\n format.json { head :ok }\n else\n format.json { render :json => @persona.errors,\n :status => :unprocessable_entity }\n end\n end\n end",
"def update\n if @diet.update(diet_params)\n head :no_content, status: 204\n else\n render json: @diet.errors, status: 422\n end\n end",
"def update\n\n @foaf.interests.clear\n\n if(foaf_params.has_key?(:interests_attributes))\n interest_ids = foaf_params[:interests_attributes].split(\",\").map { |s| s.to_i }\n interest_ids.each do |i|\n @foaf.interests << Interest.find(i)\n #@foaf.update(Interest.find(i))\n end\n \n end\n\n respond_to do |format|\n if @foaf.update(name: foaf_params[:name], work: foaf_params[:work], \n slug: foaf_params[:slug], birthday: foaf_params[:birthday])\n format.html { redirect_to @foaf, notice: 'Foaf was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @foaf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fee = Fee.find(params[:id])\n\n respond_to do |format|\n if @fee.update_attributes(params[:fee])\n format.html { redirect_to fees_path, notice: 'Fee was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(params)\n res = @client.put(path, nil, params, \"Content-Type\" => \"application/json\")\n @attributes = res.json if res.status == 201\n res\n end",
"def update\n @faafacility = Faafacility.find(params[:id])\n\n respond_to do |format|\n if @faafacility.update_attributes(params[:faafacility])\n format.html { redirect_to @faafacility, notice: 'Faafacility was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @faafacility.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fact.update(fact_params)\n format.html { redirect_to @fact, notice: 'Fact was successfully updated.' }\n format.json { render :show, status: :ok, location: @fact }\n else\n format.html { render :edit }\n format.json { render json: @fact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @appeal.update_attributes(params[:appeal])\n format.html { redirect_to [@conference, @appeal], notice: 'Appeal was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @appeal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @afp.update(afp_params)\n format.html { redirect_to @afp, notice: 'Afp was successfully updated.' }\n format.json { render :show, status: :ok, location: @afp }\n else\n format.html { render :edit }\n format.json { render json: @afp.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @agency = Agency.find(params[:id])\n\n if @agency.update(agency_params)\n #head :no_content\n render json: @agency, status: :accepted, location: @agency #sera? status accepted? \n else\n render json: @agency.errors, status: :unprocessable_entity\n end\n end",
"def update\n\trespond_to do |format|\n\t if @ad.update(ad_params)\n\t\tformat.html { redirect_to ad_path(@ad), notice: 'Ad was successfully updated.' }\n\t\tformat.json { render :show, status: :ok, location: @ad }\n\t else\n\t\tformat.html { render :edit }\n\t\tformat.json { render json: @ad.errors, status: :unprocessable_entity }\n\t end\n\tend\n end",
"def update\n respond_to do |format|\n if @ad.update(ad_params)\n format.html { redirect_to @ad, notice: 'Ad was successfully updated.' }\n format.json { render :show, status: :ok, location: @ad }\n else\n format.html { render :edit }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @ad.update(ad_params)\n format.html { redirect_to @ad, notice: 'Ad was successfully updated.' }\n format.json { render :show, status: :ok, location: @ad }\n else\n format.html { render :edit }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @ad.update(ad_params)\n format.html { redirect_to @ad, notice: 'Ad was successfully updated.' }\n format.json { render :show, status: :ok, location: @ad }\n else\n format.html { render :edit }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fee.update(fee_params)\n format.html { redirect_to @fee, notice: 'Fee was successfully updated.' }\n format.json { render :show, status: :ok, location: @fee }\n else\n format.html { render :edit }\n format.json { render json: @fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fee.update(fee_params)\n format.html { redirect_to @fee, notice: 'Fee was successfully updated.' }\n format.json { render :show, status: :ok, location: @fee }\n else\n format.html { render :edit }\n format.json { render json: @fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n #@klass_fee = KlassFee.find(params[:id])\n\n respond_to do |format|\n if @klass_fee.update_attributes(params[:klass_fee])\n format.html { redirect_to klass_klass_fees_path(@klass), notice: 'Klass fee was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @klass_fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ad = Ad.friendly.find(params[:id])\n\n respond_to do |format|\n if @ad.update(ad_params)\n format.html { redirect_to @ad, notice: \"Ad was successfully updated.\" }\n format.json { render :show, status: :ok, location: @ad }\n else\n format.html { render :edit }\n format.json { render json: @ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @futbolada = Futbolada.find(params[:id])\n\n respond_to do |format|\n if @futbolada.update_attributes(params[:futbolada])\n format.html { redirect_to gestion_url, notice: 'Futbolada was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @futbolada.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @create_classified_ad = CreateClassifiedAd.find(params[:id])\n\n respond_to do |format|\n if @create_classified_ad.update_attributes(params[:create_classified_ad])\n format.html { redirect_to @create_classified_ad, notice: 'Create classified ad was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @create_classified_ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_rest\n @entry_answer = EntryAnswer.find(params[:id])\n\n respond_to do |format|\n if @entry_answer.update_attributes(params[:entry_answer])\n flash[:notice] = 'EntryAnswer was successfully updated.'\n format.html { redirect_to(@entry_answer) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry_answer.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n budgets = update_budgets(params[:budgets])\n\n render json: budgets, status: :ok\n end",
"def update\n @fetmeeting = Fetmeeting.find(params[:id])\n\n respond_to do |format|\n if @fetmeeting.update_attributes(params[:fetmeeting])\n format.html { redirect_to @fetmeeting, notice: 'Fetmeeting was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fetmeeting.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feild.update(feild_params)\n format.html { redirect_to @feild, notice: 'Feild was successfully updated.' }\n format.json { render :show, status: :ok, location: @feild }\n else\n format.html { render :edit }\n format.json { render json: @feild.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @federation.update(federation_params)\n format.html { redirect_to @federation, notice: 'Federation was successfully updated.' }\n format.json { render :show, status: :ok, location: @federation }\n format.xml { head :ok }\n else\n format.html { render :edit }\n format.json { render json: @federation.errors, status: :unprocessable_entity }\n format.xml { render :xml => @federation.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fabricsofaset.update(fabricsofaset_params)\n format.html { redirect_to @fabricsofaset, notice: 'Fabricsofaset was successfully updated.' }\n format.json { render :show, status: :ok, location: @fabricsofaset }\n else\n format.html { render :edit }\n format.json { render json: @fabricsofaset.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n render json: Alien.update(params[\"id\"], params[\"alien\"])\n end",
"def update\n @respuesta = Respuesta.find(params[:id])\n\n if @respuesta.update(params[:respuesta])\n head :no_content\n else\n render json: @respuesta.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @fabrica.update(fabrica_params)\n format.html { redirect_to @fabrica, notice: 'Fabrica was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fabrica.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @advertisement_campaign.update(advertisement_campaign_params_to_update)\n format.html { redirect_to @advertisement_campaign, notice: 'Advertisement campaign was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @advertisement_campaign.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @budget = Budget.find(params[:id])\n\n respond_to do |format|\n if @budget.update_attributes(params[:budget])\n format.html { redirect_to @budget, notice: 'Budget was successfully updated.' }\n # format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n # format.json { render json: @budget.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @facture.update(facture_params)\n format.html { redirect_to add_ref_path(@facture), notice: 'La facture a bien été mise à jour.' }\n format.json { render :show, status: :ok, location: @facture }\n else\n format.html { render :edit }\n format.json { render json: @facture.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @agency.update(agency_params)\n format.html { redirect_to @agency, notice: 'Agency was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @agency.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @taf = Taf.find(params[:id])\n\n respond_to do |format|\n if @taf.update_attributes(params[:taf])\n format.html { redirect_to @taf, notice: 'Taf was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @taf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @featuring.update(featuring_params)\n format.html { redirect_to @featuring, notice: 'Featuring was successfully updated.' }\n format.json { render :show, status: :ok, location: @featuring }\n else\n format.html { render :edit }\n format.json { render json: @featuring.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @star_fact = Star::Fact.find(params[:id])\n\n respond_to do |format|\n if @star_fact.update_attributes(params[:star_fact])\n format.html { redirect_to @star_fact, notice: 'Fact was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @star_fact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @afformation.update(afformation_params)\n format.html { redirect_to afformations_url, notice: 'Afformation was successfully updated.' }\n format.json { render :index, status: :ok, location: @afformations }\n else\n format.html { render :edit }\n format.json { render json: @afformation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ad_contact = AdContact.find(params[:id])\n\n respond_to do |format|\n if @ad_contact.update_attributes(params[:ad_contact])\n format.html { redirect_to @ad_contact, notice: 'Ad contact was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ad_contact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @fund.update(fund_params)\n head :no_content\n else\n render json: @fund.errors, status: :unprocessable_entity\n end\n end",
"def update\n @foam = Foam.find(params[:id])\n\n respond_to do |format|\n if @foam.update_attributes(params[:foam])\n format.html { redirect_to @foam, notice: 'Foam was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foam.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fucker = Fucker.find(params[:id])\n\n respond_to do |format|\n if @fucker.update_attributes(params[:fucker])\n format.json { head :no_content }\n else\n format.json { render json: @fucker.errors, status: :internal_server_error }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tenant_fee.update(tenant_fee_params)\n format.html { redirect_to @tenant_fee, notice: 'Tenant fee was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :edit }\n format.json { render json: @tenant_fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @agency.update_attributes(params[:agency])\n format.html { redirect_to @agency, notice: 'Agency was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @agency.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @factores_fluctuante.update(factores_fluctuante_params)\n format.html { redirect_to @factores_fluctuante, notice: 'Factores fluctuante was successfully updated.' }\n format.json { render :show, status: :ok, location: @factores_fluctuante }\n else\n format.html { render :edit }\n format.json { render json: @factores_fluctuante.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @vacancy = Vacancy.find(params[:id])\n\n respond_to do |format|\n if @vacancy.update_attributes(params[:vacancy])\n format.html { redirect_to @vacancy, notice: 'Vacancy was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @vacancy.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fulcliente = Fulcliente.find(params[:id])\n\n respond_to do |format|\n if @fulcliente.update_attributes(params[:fulcliente])\n format.html { redirect_to @fulcliente, notice: 'Fulcliente was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fulcliente.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @flight.update(flight_params)\n format.html { redirect_to @flight, notice: 'Flight was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @flight.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @flight.update(flight_params)\n format.html { redirect_to @flight, notice: 'Flight was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @flight.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @flight.update(flight_params)\n format.html { redirect_to @flight, notice: 'Flight was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @flight.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @faceapi.update(faceapi_params)\n format.html { redirect_to @faceapi, notice: 'Faceapi was successfully updated.' }\n format.json { render :show, status: :ok, location: @faceapi }\n else\n format.html { render :edit }\n format.json { render json: @faceapi.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @festival.update(festival_params)\n format.html { redirect_to @festival, notice: 'Festival was successfully updated.' }\n format.json { render :show, status: :ok, location: @festival }\n else\n format.html { render :edit }\n format.json { render json: @festival.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n activo = params[:lab_far][:activo]\n farmacia_id = session[:farmacia_id]\n id = params[:id]\n LabFar.where(laboratorio_id: id, farmacium_id:farmacia_id).update_all(activo: activo )\n msg = { :status => \"ok\", :message => \"Actualizado!\" }\n format.json { render :json => msg }\n end\n end",
"def update\n respond_to do |format|\n if @cta.update(cta_params)\n format.html { redirect_to @cta, notice: 'cta was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @cta.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @vacancy.update(vacancy_params)\n update_skills\n format.html { redirect_to @vacancy, notice: 'Vacancy was successfully updated.' }\n format.json { render :show, status: :ok, location: @vacancy }\n else\n format.html { render :edit }\n format.json { render json: @vacancy.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @aadt = Aadt.find(params[:id])\n\n respond_to do |format|\n if @aadt.update_attributes(params[:aadt])\n format.html { redirect_to @aadt, notice: 'Aadt was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @aadt.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @vkontakte_campaign = VkontakteCampaign.find(params[:id])\n\n respond_to do |format|\n if @vkontakte_campaign.update_attributes(params[:vkontakte_campaign])\n format.html { redirect_to @vkontakte_campaign, notice: 'Vkontakte campaign was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @vkontakte_campaign.errors, status: :unprocessable_entity }\n end\n end\n end",
"def actualizacion \n fiesta.update (params[:id]) \n render json: fiesta\n end",
"def update\n respond_to do |format|\n if @calf.update(calf_params)\n format.html { redirect_to @calf, notice: 'Calf was successfully updated.' }\n format.json { render :show, status: :ok, location: @calf }\n else\n format.html { render :edit }\n format.json { render json: @calf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @budget = Budget.find(params[:id])\n\n respond_to do |format|\n if @budget.update_attributes(params[:budget])\n format.html { redirect_to @budget, notice: 'Budget was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @budget.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @budget = Budget.find(params[:id])\n\n respond_to do |format|\n if @budget.update_attributes(params[:budget])\n format.html { redirect_to @budget, notice: 'Budget was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @budget.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @flight.update(flight_params)\n json_response(@flight.decorate.as_json(flight_details: true), :ok)\n else\n json_response(@flight.errors, :unprocessable_entity)\n end\n end",
"def update\n @ad_post = AdPost.find(params[:id])\n\n respond_to do |format|\n if @ad_post.update_attributes(params[:ad_post])\n format.html { redirect_to @ad_post, notice: 'Ad post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ad_post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @formalizacao.update(formalizacao_params)\n format.html { redirect_to @formalizacao, notice: 'Formalizacao was successfully updated.' }\n format.json { render :show, status: :ok, location: @formalizacao }\n else\n format.html { render :edit }\n format.json { render json: @formalizacao.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @apuesta_detail = ApuestaDetail.find(params[:id])\n\n respond_to do |format|\n if @apuesta_detail.update_attributes(params[:apuesta_detail])\n format.html { redirect_to @apuesta_detail, notice: 'Apuesta detail was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @apuesta_detail.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n@magazine = Magazine.find_by_id(params[:magazine_id])\nrespond_to do |format|\nif @ad.update(ad_params)\nformat.html { redirect_to magazine_ad_path(@magazine, @ad), notice:\n'Ad was successfully updated.' }\nformat.json { render :show, status: :ok, location: @ad }\nelse\nformat.html { render :edit }\nformat.json { render json: @ad.errors, status: :unprocessable_entity }\nend\nend\nend",
"def update\n @featured_duffel = FeaturedDuffel.find_by_permalink(params[:id])\n \n cities = City.find_id_by_city_country(params[:featured_duffel][:city_country])\n trip = Trip.find_by_permalink(params[:permalink])\n user = User.find_by_username(params[:username])\n \n @featured_duffel.city_id = cities[0].id\n @featured_duffel.user_id = user.id\n @featured_duffel.trip_id = trip.id\n\n respond_to do |format|\n if @featured_duffel.update_attributes(params[:featured_duffel])\n flash[:notice] = 'Featured Duffel was successfully updated.'\n format.html { redirect_to(@featured_duffel) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @featured_duffel.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fee_category.update(fee_category_params)\n format.html { redirect_to @fee_category, notice: 'Fee category was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fee_category.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @admission_form = AdmissionForm.find(params[:id])\n\n respond_to do |format|\n if @admission_form.update_attributes(params[:admission_form])\n format.html { redirect_to @admission_form, notice: 'Admission form was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @admission_form.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @faculty.update(faculty_params)\n head :no_content\n end",
"def update\n @spoofer = Spoofer.find(params[:id])\n\n respond_to do |format|\n if @spoofer.update_attributes(params[:spoofer])\n format.html { redirect_to @spoofer, notice: 'Spoofer was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @spoofer.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @facebook_ad.update(facebook_ad_params)\n format.html { redirect_to @facebook_ad, notice: 'Facebook ad was successfully updated.' }\n format.json { render :show, status: :ok, location: @facebook_ad }\n else\n format.html { render :edit }\n format.json { render json: @facebook_ad.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n render json: Post.update(params[\"id\"], params[\"post\"])\n end",
"def update\n @feeling = Feeling.find(params[:id])\n\n respond_to do |format|\n if @feeling.update_attributes(params[:feeling])\n format.html { redirect_to @feeling, notice: 'Feeling was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feeling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @ad.update(ad_params)\n render :show, status: :ok, location: @ad\n else\n render json: @ad.errors, status: :unprocessable_entity\n end\n end",
"def update\n @adopter = Adopter.find(params[:id])\n\n if @adopter.update(adopter_params)\n head :no_content\n else\n render json: @adopter.errors, status: :unprocessable_entity\n end\n end",
"def update\n @consulta = Consulta.find(params[:id])\n\n if @consulta.update(params[:consulta])\n head :no_content\n else\n render json: @consulta.errors, status: :unprocessable_entity\n end\n end",
"def update\n @flight = Flight.find(params[:id])\n\n respond_to do |format|\n if @flight.update_attributes(params[:flight])\n format.html { redirect_to @flight, notice: 'Flight was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @flight.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch!\n request! :patch\n end",
"def update\n respond_to do |format|\n if @fast.update(fast_params)\n format.html { redirect_to @fast, notice: 'Fast was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @fast.errors, status: :unprocessable_entity }\n end\n end\n end"
] | [
"0.66114604",
"0.65853953",
"0.6457552",
"0.6439625",
"0.6432518",
"0.6423681",
"0.6365431",
"0.63600934",
"0.63593006",
"0.6349805",
"0.6325292",
"0.631922",
"0.631922",
"0.63149345",
"0.63098145",
"0.63076884",
"0.6291455",
"0.62908506",
"0.6287608",
"0.6283915",
"0.6268649",
"0.62624425",
"0.6260459",
"0.6255131",
"0.62479657",
"0.622863",
"0.6200215",
"0.61962235",
"0.6173757",
"0.61731195",
"0.61625665",
"0.6153283",
"0.614693",
"0.614693",
"0.614693",
"0.6145314",
"0.6145314",
"0.6137576",
"0.6130292",
"0.6120465",
"0.611785",
"0.61174315",
"0.6116663",
"0.61142087",
"0.6107347",
"0.6100564",
"0.60969824",
"0.60941994",
"0.60921484",
"0.60912013",
"0.6089002",
"0.6086497",
"0.6084611",
"0.60810333",
"0.60806143",
"0.60797745",
"0.6072621",
"0.60708076",
"0.6069728",
"0.60691255",
"0.6062217",
"0.60618556",
"0.6061698",
"0.6059455",
"0.6058943",
"0.6057095",
"0.60565406",
"0.60565215",
"0.60565215",
"0.60565215",
"0.60548115",
"0.60461205",
"0.604185",
"0.6041018",
"0.6040327",
"0.603767",
"0.60362774",
"0.6035686",
"0.60344833",
"0.6032554",
"0.6032554",
"0.6024386",
"0.6021884",
"0.60171384",
"0.6014082",
"0.60125923",
"0.60104513",
"0.60095847",
"0.60084134",
"0.600829",
"0.6006348",
"0.60047734",
"0.59998256",
"0.5997977",
"0.5996728",
"0.5996259",
"0.5996258",
"0.5995524",
"0.59938323",
"0.5993357"
] | 0.6741723 | 0 |
DELETE /facultads/1 DELETE /facultads/1.json | def destroy
@facultad.destroy
respond_to do |format|
format.html { redirect_to facultads_url, notice: 'Facultad was successfully destroyed.' }
format.json { head :no_content }
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\nrender json: 1\n end",
"def destroy\n @facult.destroy\n respond_to do |format|\n format.html { redirect_to facults_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to ads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admeafit.destroy\n respond_to do |format|\n format.html { redirect_to admeafits_url, notice: 'Admeafit was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @facultad.destroy\n respond_to do |format|\n format.html { redirect_to facultades_url, notice: \"Facultad ha sido eliminada.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @home_indices_ad = Home::Indices::Ad.find(params[:id])\n @home_indices_ad.destroy\n\n respond_to do |format|\n format.html { redirect_to home_indices_ads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @festival = Festival.find(params[:id])\n @festival.destroy\n\n respond_to do |format|\n format.html { redirect_to festivals_url }\n format.json { head :no_content }\n end\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def delete\n render json: Alien.delete(params[\"id\"])\n end",
"def destroy\n @aadt = Aadt.find(params[:id])\n @aadt.destroy\n\n respond_to do |format|\n format.html { redirect_to aadts_url }\n format.json { head :no_content }\n end\n end",
"def delete\n render :json => @fiestas.delete_at(params[:id].to_i)\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to org_ads_url(@ad.org), notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @actividad = Actividad.find(params[:id])\n @actividad.destroy\n\n respond_to do |format|\n format.html { redirect_to actividads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_path, notice: 'Quảng cáo đã được xóa.' }\n format.json { head :no_content }\n end\n end",
"def deletef\n url = prefix + \"deletef\" + id_param\n return response(url)\n end",
"def destroy\n @faafacility = Faafacility.find(params[:id])\n @faafacility.destroy\n\n respond_to do |format|\n format.html { redirect_to faafacilities_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @adss.destroy\n respond_to do |format|\n format.html { redirect_to adsses_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advertisement_campaign.destroy\n respond_to do |format|\n format.html { redirect_to advertisement_campaigns_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @fascicle.destroy\n respond_to do |format|\n format.html { redirect_to fascicles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @frat.destroy\n respond_to do |format|\n format.html { redirect_to frats_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n # @advertisement = Advertisement.find(params[:id])\n @advertisement.destroy\n respond_to do |format|\n format.html { redirect_to advertisements_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @advert.destroy\n respond_to do |format|\n format.html { redirect_to adverts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_url, notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_url, notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_url, notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_url, notice: \"Ad was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advert = Advert.find(params[:id])\n @advert.destroy\n\n respond_to do |format|\n format.html { redirect_to adverts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advert = Advert.find(params[:id])\n @advert.destroy\n\n respond_to do |format|\n format.html { redirect_to adverts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @aff.destroy\n respond_to do |format|\n format.html { redirect_to affs_url, notice: 'Aff was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { render :action => :admin_dash, :id => 1, :uuid => @uuid }\n format.json { head :no_content }\n end\n end",
"def destroy\n @adherent.destroy\n respond_to do |format|\n format.html { redirect_to adherents_url, notice: 'Adherent was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @aactio = Aactio.find(params[:id])\n @aactio.destroy\n\n respond_to do |format|\n format.html { redirect_to aactios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @adult.destroy\n respond_to do |format|\n format.html { redirect_to adults_url, notice: 'Adult was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @futbolada = Futbolada.find(params[:id])\n @futbolada.destroy\n\n respond_to do |format|\n format.html { redirect_to gestion_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advertisement = Advertisement.find(params[:id])\n @advertisement.destroy\n\n respond_to do |format|\n format.html { redirect_to advertisements_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to @user, notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @creative.destroy\n respond_to do |format|\n format.html { redirect_to creatives_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advertisement = Advertisement.find(params[:id])\n #if File.exists?(\"#{Rails.root}/#{@advertisement.filename}\")\n #File.delete(\"#{@advertisement.filename}\")\n #end\n @advertisement.destroy\n\n respond_to do |format|\n format.html { redirect_to advertisements_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advocacy = Advocacy.find(params[:id])\n @advocacy.destroy\n\n respond_to do |format|\n format.html { redirect_to advocacies_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @actum.destroy\n respond_to do |format|\n format.html { redirect_to acta_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @apuesta_detail = ApuestaDetail.find(params[:id])\n @apuesta_detail.destroy\n\n respond_to do |format|\n format.html { redirect_to apuesta_details_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad_banner.destroy\n respond_to do |format|\n format.html { redirect_to ad_banners_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @adcategory.destroy\n respond_to do |format|\n format.html { redirect_to adcategories_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contestant = Contestant.find(params[:id])\n @contestant.destroy\n\n respond_to do |format|\n format.html { redirect_to contestants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n@magazine = Magazine.find_by_id(params[:magazine_id])\[email protected]\nrespond_to do |format|\nformat.html { redirect_to magazine_ads_path(@magazine), notice: 'Ad was successfully destroyed.' }\nformat.json { head :no_content }\nend\nend",
"def destroy\n @humanidades1 = Humanidades1.find(params[:id])\n @humanidades1.destroy\n\n respond_to do |format|\n format.html { redirect_to humanidades1s_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad.destroy\n respond_to do |format|\n format.html { redirect_to ads_url, notice: 'Post was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission.destroy\n respond_to do |format|\n format.html { redirect_to admissions_url, notice: 'Admission was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @aucrecord.destroy\n respond_to do |format|\n format.html { redirect_to aucrecords_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @facultade.destroy\n respond_to do |format|\n format.html { redirect_to facultades_url, notice: 'Facultade was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advert1.destroy\n respond_to do |format|\n format.html { redirect_to advert1s_url, notice: 'Advert1 was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @fud_entry.destroy\n respond_to do |format|\n format.html { redirect_to fud_entries_url, notice: 'Fud entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @fabrica.destroy\n respond_to do |format|\n format.html { redirect_to fabricas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ai_contest = AiContest.find(params[:id])\n @ai_contest.destroy\n\n respond_to do |format|\n format.html { redirect_to ai_contests_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n\[email protected]\n\trespond_to do |format|\n\t format.html { redirect_to ads_url, notice: 'Ad was successfully destroyed.' }\n\t format.json { head :no_content }\n\tend\n end",
"def destroy\n @campaign_banner.destroy\n respond_to do |format|\n format.html { redirect_to campaign_banners_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @facebook_ad.destroy\n respond_to do |format|\n format.html { redirect_to facebook_ads_url, notice: 'Facebook ad was successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @create_classified_ad = CreateClassifiedAd.find(params[:id])\n @create_classified_ad.destroy\n\n respond_to do |format|\n format.html { redirect_to create_classified_ads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @asignatura.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @detalle = Detalle.find(params[:id])\n @detalle.destroy\n\n respond_to do |format|\n format.html { redirect_to detalles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @actividad.destroy\n respond_to do |format|\n format.html { redirect_to actividads_url, notice: 'Actividad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @audience = Audience.find(params[:id])\n @audience.destroy\n\n respond_to do |format|\n format.html { redirect_to audiences_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @advertisement.destroy\n respond_to do |format|\n format.html { redirect_to advertisements_url, notice: 'Ad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission.destroy\n respond_to do |format|\n format.html { redirect_to admissions_url, notice: 'Admission information was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @taf = Taf.find(params[:id])\n @taf.destroy\n\n respond_to do |format|\n format.html { redirect_to tafs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad_plan.destroy\n respond_to do |format|\n format.html { redirect_to ad_plans_url, notice: 'Ad plan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foaf.destroy\n\n respond_to do |format|\n format.html { redirect_to foafs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foaf.destroy\n\n respond_to do |format|\n format.html { redirect_to foafs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @publicidad = Publicidad.find(params[:id])\n @publicidad.destroy\n\n respond_to do |format|\n format.html { redirect_to publicidads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ad_contact = AdContact.find(params[:id])\n @ad_contact.destroy\n\n respond_to do |format|\n format.html { redirect_to ad_contacts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @persona = Persona.find(params[:id])\n @persona.destroy\n\n respond_to do |format|\n format.json { head :ok }\n end\n \n end",
"def destroy\n @accolade.destroy\n respond_to do |format|\n format.html { redirect_to accolades_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @festival.destroy\n respond_to do |format|\n format.html { redirect_to festivals_url, notice: 'Festival was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @fast.destroy\n respond_to do |format|\n format.html { redirect_to fasts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @humanidades3 = Humanidades3.find(params[:id])\n @humanidades3.destroy\n\n respond_to do |format|\n format.html { redirect_to humanidades3s_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @creative.destroy\n respond_to do |format|\n format.html { redirect_to campaign_creatives_url(@campaign), notice: 'Вид рекламы удален.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @diciplina = Diciplina.find(params[:id])\n @diciplina.destroy\n\n respond_to do |format|\n format.html { redirect_to diciplinas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @asignatura = Asignatura.find(params[:id])\n @asignatura.destroy\n\n respond_to do |format|\n format.html { redirect_to asignaturas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @asignatura = Asignatura.find(params[:id])\n @asignatura.destroy\n\n respond_to do |format|\n format.html { redirect_to asignaturas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @funcionalidad.destroy\n respond_to do |format|\n format.html { redirect_to funcionalidads_url, notice: 'Funcionalidad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n #@klass_fee = KlassFee.find(params[:id])\n #@klass_fee.destroy\n\n respond_to do |format|\n format.html { redirect_to klass_fees_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lead.destroy\n\n respond_to do |format|\n format.html { redirect_to leads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @claimant = Claimant.find(params[:id])\n @claimant.destroy\n\n respond_to do |format|\n format.html { redirect_to claimants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n id = params[:id]\n src = Tagaly3::SRC\n # Code to connect with API\n @uri = URI.parse(src)\n http = Net::HTTP.start(@uri.host,@uri.port)\n request = Net::HTTP::Delete.new(\"/adexchange/advertiser/advertisement/#{id}\")\n response = http.request(request)\n http.finish\n redirect_to '/ads/'\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to(ads_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to(ads_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to ads_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to ads_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @ad = Ad.find(params[:id])\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to ads_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @ad.destroy\n\n respond_to do |format|\n format.html { redirect_to(ads_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @advert = @advert_class.find(params[:id])\n @advert.destroy\n\n respond_to do |format|\n format.html { redirect_to adverts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @diet.destroy\n head :no_content, status: 200\n else\n render json: @diet.errors, status: 405\n end\n end",
"def destroy\n @ad_unit = AdUnit.find(params[:id])\n @ad_unit.destroy\n\n respond_to do |format|\n format.html { redirect_to ad_units_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @ad_post = AdPost.find(params[:id])\n @ad_post.destroy\n\n respond_to do |format|\n format.html { redirect_to ad_posts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @vacancy = Vacancy.find(params[:id])\n @vacancy.destroy\n\n respond_to do |format|\n format.html { redirect_to vacancies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cafeterium.destroy\n respond_to do |format|\n format.html { redirect_to cafeteria_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n franchise.destroy\n\n respond_to do |format|\n format.html { redirect_to franchises_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n [email protected]_id\n @familia.destroy\n respond_to do |format|\n format.html { redirect_to familias_url(:id => padre) }\n format.json { head :no_content }\n end\n end",
"def destroy \n @advertisement.destroy\n respond_to do |format|\n format.html { redirect_to advertisements_url, notice: 'Advertisement was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @adecuacionactividad.destroy\n respond_to do |format|\n format.html { redirect_to adecuacionactividads_url, notice: 'Adecuacionactividad was successfully destroyed.' }\n format.json { head :no_content }\n end\n end"
] | [
"0.721781",
"0.7063725",
"0.70537746",
"0.7037346",
"0.70180774",
"0.6994423",
"0.6971863",
"0.6966238",
"0.69628984",
"0.6944445",
"0.69440275",
"0.6929412",
"0.69126105",
"0.6891235",
"0.68901837",
"0.68723595",
"0.6872174",
"0.6868168",
"0.68680644",
"0.68605125",
"0.68458176",
"0.68449694",
"0.6833041",
"0.6833041",
"0.6833041",
"0.6832938",
"0.67983794",
"0.67983794",
"0.67912185",
"0.67900676",
"0.67883784",
"0.6774639",
"0.67717284",
"0.6767827",
"0.67671865",
"0.67626953",
"0.67617816",
"0.6759743",
"0.67582405",
"0.6747866",
"0.67457646",
"0.67422915",
"0.6734797",
"0.6731243",
"0.6730992",
"0.67233235",
"0.6714797",
"0.670885",
"0.6707555",
"0.6706654",
"0.67036957",
"0.6703033",
"0.669842",
"0.6697851",
"0.66921467",
"0.66907",
"0.66878223",
"0.6684982",
"0.6680119",
"0.66796154",
"0.66791975",
"0.6672856",
"0.6669437",
"0.6666645",
"0.6666602",
"0.6661483",
"0.6660003",
"0.6660003",
"0.66587037",
"0.6658372",
"0.6657589",
"0.66551185",
"0.6654835",
"0.6654456",
"0.6653807",
"0.665143",
"0.6650413",
"0.6647902",
"0.6647902",
"0.66463244",
"0.66410136",
"0.663722",
"0.66365725",
"0.66359085",
"0.6632246",
"0.6632246",
"0.6631647",
"0.6631647",
"0.6631647",
"0.6627631",
"0.66246563",
"0.6623807",
"0.6622166",
"0.6618771",
"0.66179806",
"0.6617116",
"0.6616396",
"0.66155654",
"0.6614794",
"0.661433"
] | 0.7341869 | 0 |
Use callbacks to share common setup or constraints between actions. | def set_facultad
@facultad = Facultad.find(params[:id])
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] | [
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] | 0.0 | -1 |
Never trust parameters from the scary internet, only allow the white list through. | def facultad_params
params.require(:facultad).permit(:Nombre_facultad, :Direccion)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] | [
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] | 0.0 | -1 |
01/01/2015 Sample code to list instances from Atlantic.net using Ruby | def list_instances
puts "OK, Listing instances.."
response = RestClient.post(
$uri,
'Version' => '2010-12-30',
'ACSAccessKeyId' => $ACSAccessKeyId,
'Format' => 'json',
'Timestamp' => $current_time,
'Rndguid' => $rndguid,
'Signature' => calculate_signature($api_private_key, $rndguid, $current_time),
'Action' => "list-instances")
puts response
puts response.code
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def instances; end",
"def instances; end",
"def instances\n instances = []\n JSON.parse(resource['/instances'].get)[\"instances\"].each do |i|\n instances << Instance.new(i)\n end\n return instances\n end",
"def list\n attrcheck = { 'compartment' => @options[:compartment] }\n @validate.validate(@options, attrcheck)\n opts = {}\n opts[:availability_domain] = @options[:availability_domain] if @options[:availability_domain]\n opts[:display_name] = @options[:display_name] if @options[:display_name]\n BmcAuthenticate.new(@options)\n request = OracleBMC::Core::ComputeClient.new\n request = request.list_instances(@options[:compartment], opts)\n request.data\n end",
"def show_list\n\t\tclear\n\t\tputs \"= LISTE DES INSTANCES #{name} =\".bleu\n\t\tputs \"\\n\\n\"\n\t\tlen_delim = defined?(LIST_ENTETE) ? LIST_ENTETE.length + 2 : 80\n\t\tdelim = (\"-\"*len_delim).bleu\n\t\tif defined?(LIST_ENTETE)\n\t\t\tputs delim\n\t\t\tputs LIST_ENTETE \n\t\tend\n\t\tputs delim\n\t\tall.each do |inst|\n\t\t\tputs \" #{inst.to_console}\"\n\t\tend\n\t\tputs delim\n\t\tputs \"\\n\\n\"\n\tend",
"def instances\n IbmCloudRest.get \"#{@uri}/instances\"\n end",
"def list\n get()\n end",
"def list\n\n end",
"def list klass, names, options, check_remote = false, &block\n ResourceInfo.list klass, self, names, options, check_remote, &block\n end",
"def list_command\n age = get_param(\"age\\=\", \"(\\d+)\")\n type = get_param(\"type\\=\", \"([a-zA-Z]+)\")\n\n @app.list_animals(age, type)\n end",
"def index\n @instances = Instance.all\n end",
"def index\n @instances = Instance.all\n end",
"def instances\n end",
"def instances(return_type)\n return nil unless(active_rdf? && is_iri?)\n qry = ActiveRDF::Query.new(URI).distinct.select(:s)\n qry.where(:s, RDF.type, self)\n qry.execute\n end",
"def find_all\n response = fetch()\n new(response)\n end",
"def index\n page = params[:page]\n per_page = (params[:per_page] || 10).to_i\n if page\n entities = _all_instances_query.page(page).per(per_page)\n render json: entities, entity: _get_class,\n meta: { total_pages: entities.total_pages, total_count: entities.total_count }\n else\n entities = _all_instances_query\n respond_with entities, entity: '_get_class'\n end\n end",
"def classes\n @title = 'Puppet Class Listing A-Z'\n @objects_by_letter = objects_by_letter(:puppet_class)\n erb(:objects)\nend",
"def instances\n Egi::Fedcloud::Vmhound::Log.info \"[#{self.class}] Retrieving active instances\"\n fetch_instances\n end",
"def listBooks\n # not sure how we go from Book class to books array, so this method does not work, \n # because there is no books array.\n # http://stackoverflow.com/questions/14532844/ruby-array-of-objects-classes\n # books = [@bookname]\n # Book.all_instances\n books.each do |book|\n puts book\n end\n end",
"def list_animals \n puts \"Here are the current animals in shelter: \"\n @animals_in_shelter.each do |animal|\n puts animal.get_animal_info\n end\n end",
"def list(*) end",
"def list()\n puts \"Listing all endpoints\"\n load_manifest\n\n pp manifest.keys\n\n end",
"def list\n\nputs \"\nThis is the list of citizens created:\"\nPolitician.list_politician\nPerson.list_people\n\nend",
"def list(options = {})\n url = build_url(options)\n response = rest_get(url)\n JSON.parse(response)['value'].map { |hash| Azure::Armrest::Usage.new(hash) }\n end",
"def getPAYGInstances\n self.class.get('/v1/payAsYouGo/bareMetals/instances', @options)\n end",
"def list\n end",
"def list\n end",
"def list\n end",
"def init_instances\n instances = []\n next_token = nil\n all_records_retrieved = false\n\n until all_records_retrieved\n response = @@client.describe_instances({\n next_token: next_token\n })\n next_token = response.next_token\n all_records_retrieved = next_token.nil? || next_token.empty?\n instances << response.reservations.map { |r| r.instances }\n end\n\n instances.flatten\n end",
"def servers_with_class(classname)\n hosts = []\n query = ['and', ['=', 'type', 'Class'], ['=', 'title', classname]]\n response = request('resources', query)\n response.each do |r|\n hostname = r['certname']\n hosts << hostname\n end\n\n hosts\nend",
"def list(klass, params)\n DSpaceObj.get(self, self.link + klass::PATH, params)\n end",
"def list(type, parameters)\n @type = type # Keep this around to structure the output\n @response = self.request(Net::HTTP::Get.new(\n \"/#{type}.#{Format}?#{parameters}\"\n ))\n self.to_s\n end",
"def list_instances(request_id)\n instances = []\n JSON.parse(resource[\"/requests/#{request_id}\"].get)[\"instances\"].each do |i|\n instances << Instance.new(i)\n end\n end",
"def all\n ALLOCATIONS.map do |a|\n new(a.fetch(:title), a.fetch(:type), a)\n end\n end",
"def run\n super\n\n # Make sure the key is set\n raise \"API KEY MISSING: shodan_api_key\" unless $intrigue_config[\"shodan_api_key\"]\n\n @client = Client::Search::Shodan::ApiClient.new($intrigue_config[\"shodan_api_key\"])\n response = @client.search(_get_entity_attribute \"name\")\n\n # check to make sure we got a response.\n raise \"ERROR: No response\" unless response\n\n # Check to make sure we got results\n if response[\"matches\"]\n\n @task_log.log \"Found #{response[\"matches\"].count} matches\"\n\n # Go through the results\n response[\"matches\"].each do |r|\n\n @task_log.log \"* SHODAN Record *\"\n\n #updated_at = DateTime.new(r[\"updated\"])\n updated_at = DateTime.now\n\n #\n # Create a host record\n #\n @task_log.log \"IP: #{r[\"ip\"]}\"\n host = _create_entity(\"IpAddress\",{\n :name => \"#{r[\"ip\"]}\",\n :age => \"#{updated_at}\"\n }) if r[\"ip\"]\n\n #\n # Create a DNS record for all hostnames\n #\n r[\"hostnames\"].each do |h|\n @task_log.log \"Hostname: #{h}\"\n _create_entity(\"DnsRecord\",{ :name => \"#{h}\", :age => \"#{updated_at}\" })\n end\n\n #\n # Create a netsvc\n #\n @task_log.log \"Port: #{r[\"port\"]}\"\n\n port = _create_entity(\"NetSvc\",{\n :name => \"#{host.attributes[:name]}:#{r[\"port\"]}/tcp\",\n :proto => \"tcp\",\n :port_num => r[\"port\"],\n :fingerprint => r[\"data\"],\n :age => \"#{updated_at}\"\n }) if r[\"port\"]\n\n #\n # Create an organization\n #\n @task_log.log \"Org: #{r[\"org\"]}\"\n org = _create_entity(\"Organization\",{\n :name => \"#{r[\"org\"]}\",\n :age => \"#{updated_at}\"\n }) if r[\"org\"]\n\n #\n # Create a PhysicalLocation\n #\n @task_log.log \"Location: #{r[\"postal_code\"]}\"\n location = _create_entity(\"PhysicalLocation\",{\n :name => \"#{r[\"latitude\"]} / #{r[\"longitude\"]}\",\n :zip => \"#{r[\"postal_code\"]}\",\n :state => \"#{r[\"region_name\"]}\",\n :country => \"#{r[\"country_name\"]}\",\n :latitude => \"#{r[\"latitude\"]}\",\n :longitude => \"#{r[\"longitude\"]}\",\n :age => \"#{updated_at}\"\n }) if r[\"country_name\"]\n\n\n @task_log.log \"Port: #{r[\"port\"]}\"\n @task_log.log \"Port Data: #{r[\"data\"]}\"\n @task_log.log \"Country: #{r[\"country_name\"]}\"\n @task_log.log \"Country Code: #{r[\"country_code\"]}\"\n @task_log.log \"Region Name: #{r[\"region_name\"]}\"\n @task_log.log \"Area Code: #{r[\"area_code\"]}\"\n @task_log.log \"DMA Code: #{r[\"dma_code\"]}\"\n @task_log.log \"Postal Code: #{r[\"postal_code\"]}\"\n @task_log.log \"Org: #{r[\"org\"]}\"\n\n end\n end\n end",
"def list_of_instances\n super\n end",
"def list\n url = prefix + \"list\"\n return response(url)\n end",
"def initialize\n\n response = list\n end",
"def active_instances; end",
"def all(params=nil)\n instance = ConektaObject.new\n url = Util.types[self.class_name.downcase].url\n requestor = Requestor.new\n response = requestor.request(:get, url)\n instance.load_from(response)\n instance\n end",
"def listar()\n @client.get(Route.new([ROTA_DID]))\n end",
"def cmd_list argv\n setup argv\n type = @hash['type']\n response = @api.list(type)\n if response.is_a?(Array)\n response.each do | r |\n msg r\n end\n else\n msg response\n end\n return response\n end",
"def instances(type)\n @instances[type]\n end",
"def list(options, args)\n if !options[:host]\n # This case is to list available hosts, instead other object\n list_hosts(options)\n else\n vi_client = VCenterDriver::VIClient.new_from_host(\n options[:host]\n )\n importer = VCenterDriver::VcImporter.new_child(\n @client,\n vi_client,\n options[:object]\n )\n\n list_object(options, importer.retrieve_resources(args))\n end\n end",
"def all_instances\n Puppet.debug(\"all_instances - cached instances is: #{cached_instances}\")\n Puppet.debug(\"all_instances - cached instances object id: #{cached_instances.object_id}\")\n # return cache if it has been created, this means that this function will only need\n # to be loaded once, returning all instances that exist of this resource in vsphere\n # then, we can lookup our version by name/id/whatever. This saves a TON of processing\n return cached_instances unless cached_instances.nil?\n\n # Want to return an array of instances\n # each hash should have the same properties as the properties\n # of this \"type\"\n # remember the keys should be symbols, aka :ntp_servers not 'ntp_servers'\n # This is a tracking hash which will contain info about each host and NTP server relationships\n cmd = <<-EOF\n $ntp_servers_hash = @{}\n $hosts = #{powercli_get_online_hosts}\n foreach($h in $hosts) {\n $servers = Get-VMHostNtpServer -VMHost $h\n if ($servers) {\n $ntp_servers_hash[$h.Name] = @($servers)\n } else {\n $ntp_servers_hash[$h.Name] = @()\n }\n }\n $ntp_servers_hash | ConvertTo-Json\n EOF\n\n ntpservers_stdout = powercli_connect_exec(cmd)[:stdout]\n # json parse expects a json string, powershell does not stdout with quotes\n # we might be able to remove this line because powershell exits with a viable ruby array already:\n # [\n # \"time1.dev.encore.tech\",\n # \"time2.dev.encore.tech\"\n # ]\n # what happens if this returns null??\n ntpservers_hash = JSON.parse(ntpservers_stdout)\n\n # create instance hash - this contains info about ONE host at a time\n # the values should match the data \"shape\" (ie have the same fields) as our\n # type.\n # the key, should be the title/namevar so we can do a lookup in our\n # read_instance function\n cached_instances_set({})\n ntpservers_hash.each do |esx_host, ntp_servers_array|\n cached_instances[esx_host] = {\n ensure: :present,\n esx_host: esx_host,\n ntp_servers: ntp_servers_array,\n }\n end\n Puppet.debug(\"all_instances - cached instances is at end: #{cached_instances}\")\n Puppet.debug(\"all_instances - cached instances object_id at end: #{cached_instances.object_id}\")\n cached_instances\n end",
"def list_instances(an_array)\n SystemRepository.__list_instances(an_array)\n end",
"def list_instances request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_list_instances_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::BareMetalSolution::V2::ListInstancesResponse.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def instances\n @instances ||= []\n end",
"def inst_list(inst_id)\n uri = URI.parse(@url + '/' + inst_id) \n http = Net::HTTP.new(uri.host, uri.port, @proxy_addr, @proxy_port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Get.new(uri.request_uri)\n request.basic_auth user, passwd\n request.add_field 'X-ID-TENANT-NAME', id_domain\n http.request(request)\n end",
"def list(opts = {})\n search_provider.list(opts)\n end",
"def list\n call! :list\n end",
"def list\n url = prefix + \"list\"\n return response(url)\n end",
"def fetch_classes_list\n uri = URI(BASE_URI + \"classes\")\n classes = make_request(uri)\n classes_instances = classes[\"results\"].map do |classes_data|\n Classes.new classes_data[\"name\"]\n end\n end",
"def index\n @instances = Instance.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @instances }\n end\n end",
"def index\n @instances = Instance.page params[:page]\n authorize! :read, @instances\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @instances }\n end\n end",
"def run(*args)\n prepare_codebase(*args)\n context = API::List.new(codebase, @options)\n Output::List.new(@options, context.objects, context.grade_lists)\n end",
"def list_instances()\n response = dbreq(\"GET\",lbmgmthost,\"#{lbmgmtpath}/instances\",lbmgmtport,lbmgmtscheme)\n CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)\n instances = CloudDB.symbolize_keys(JSON.parse(response.body)[\"instances\"])\n return instances\n end",
"def index\n results = []\n if params[:bbox]\n results = VAFacility.query(bbox: params[:bbox], type: params[:type], services: params[:services])\n end\n resource = Common::Collection.new(::VAFacility, data: results)\n resource = resource.paginate(pagination_params)\n render json: resource.data,\n serializer: CollectionSerializer,\n each_serializer: VAFacilitySerializer,\n meta: resource.metadata\n end",
"def get_instances_description\n instances\n end",
"def list_tenants_for_circle(args = {}) \n get(\"/tenantcircles.json/tenants\", args)\nend",
"def list_applications(client)\n client.applications.each do |application|\n puts \"Application: #{application.name}\"\n puts \" Description: #{application.description}\"\n puts \" Status: #{application.status}\"\n puts \" Href: #{application.href}\"\n end \nend",
"def list; end",
"def list; end",
"def list; end",
"def list; end",
"def list; end",
"def index\n @instance_types = InstanceType.all\n end",
"def test_all\n assert_gets(\"/api/v2/#{api_class}?offset=0&limit=999\") { wf.all }\n end",
"def list\n get(format(LIST)).collect do |obj| \n GistObject.new(obj)\n end\n end",
"def list\n self.class.list\n end",
"def run\n super\n\n ip_address = _get_entity_attribute \"name\"\n\n c = Client::Search::Cymru::IPAddress.new\n c.whois(ip_address)\n\n # result = [“27357”, “US”, “ARIN”, “2003-02-20”, “RACKSPACE - RACKSPACE HOSTING”]\n #:asnum, :cidr, :country, :registry, :allocdate, :asname\n\n _create_entity \"AsNumber\", {\n :number => c.asnum,\n :country => c.country,\n :cidr => c.cidr,\n :registry => c.registry,\n :allocated => c.allocdate,\n :name => c.asname\n }\n end",
"def list(offset = 0, limit = 100)\n api.get('', offset: offset, limit: limit)\n end",
"def list(offset = 0, limit = 100)\n api.get('', offset: offset, limit: limit)\n end",
"def list(offset = 0, limit = 100)\n api.get('', offset: offset, limit: limit)\n end",
"def list(offset = 0, limit = 100)\n api.get('', offset: offset, limit: limit)\n end",
"def list_object(options, list)\n vcenter_host = list.keys[0]\n list = cli_format(list.values.first)\n table = format_list\n\n show_header(vcenter_host)\n\n table.show(list, options)\n end",
"def showlist\n\t\t@people_list.each do |x|\n\t\t\tputs \"* #{capitalize(x.type)}, #{capitalize(x.name)}, #{capitalize(x.party)}\"\n\t\tend\n\tend",
"def get_by_id(id)\n self.class.get(\"/aldebaran-instances/instances/#{id}\", :basic_auth => @auth)\n end",
"def get_ec2_list_info(name_regex)\n ec2 = Aws::EC2::Client.new()\n\n # Load VPCs\n vpcs={}\n ec2.describe_vpcs( {filters:[AVAILABLE_STATE_FILTER]} ).vpcs.each do |vpc|\n vpcs[ vpc.vpc_id ] = { name: getName(vpc.tags), cidr: vpc.cidr_block, subnets: {} }\n end\n\n # Load subnets\n ec2.describe_subnets( {filters:[AVAILABLE_STATE_FILTER]} ).subnets.each do |sn|\n vpc = vpcs[ sn.vpc_id ]\n vpc[:subnets][ sn.subnet_id ] = { name: getName(sn.tags), zone: sn.availability_zone, cidr: sn.cidr_block, instances: [] }\n end\n\n ec2_classic = []\n\n # Load instances\n instances = ec2.describe_instances().reservations.map { |r| r.instances } .flatten\n instances.each do |i|\n next if name_regex and not name_regex =~ getName(i.tags)\n instance = make_instance( i )\n if i.vpc_id\n vpc = vpcs[ i.vpc_id ]\n sn = vpc[:subnets][ i.subnet_id ]\n sn[:instances] << instance\n else\n ec2_classic << instance\n end\n end\n\n [vpcs, ec2_classic]\nend",
"def object_list_response(node, type)\n node = clean_node node\n class_name = ZIMBRA_TYPES_HASH[type][:class].name.gsub(/Zimbra::/, '')\n Zimbra::BaseService::Parser.response(class_name, node, false)\n end",
"def print_animal_list(input)\n puts \"\", \"Listing the animals under the #{input} conservation status.\"\n puts \"\", \" Animal Name Scientific Name \"\n puts \"-------------------------------------------------------------------\"\n EndangeredAnimals::Animal.reset\n EndangeredAnimals::Scraper.create_from_index_page(input)\n animals = EndangeredAnimals::Animal.all\n animals.each.with_index(1) do |animal, index|\n puts \"#{index.to_s.rjust(2)}#{\".\".ljust(3)} #{animal.name.ljust(28)} #{animal.scientific_name.ljust(30)}\"\n end\n end",
"def run\n super\n\n #\n # This module currently uses the Free API (rate limited / response limited)\n # https://freeapi.robtex.com/ipquery/#{search_ip}\n #\n # Note that a paid version (free up to 10k queries / month) of the API is available at:\n # https://market.mashape.com/robtex/robtex\n #\n\n # Check Robtex API & create entities from returned JSON\n search_ip = _get_entity_name\n search_uri = \"https://freeapi.robtex.com/ipquery/#{search_ip}\"\n\n begin\n details = JSON.parse(http_get_body(search_uri))\n _log \"Got details: #{details}\"\n\n #status\n # Should be \"ok\"\n unless details[\"status\"] == \"ok\"\n _log_error \"Unable to continue\"\n return\n end\n\n #act\n # Active (forward) DNS\n if details[\"act\"]\n details[\"act\"].each do |forward_lookup|\n _create_entity \"DnsRecord\",{\n \"name\" => forward_lookup[\"o\"],\n \"time\" => \"#{Time.at(forward_lookup[\"t\"])}\"\n }\n end\n end\n\n #pas\n # Passive (reverse) DNS\n if details[\"pas\"]\n details[\"pas\"].each do |reverse_lookup|\n _create_entity \"DnsRecord\",{\n \"name\" => reverse_lookup[\"o\"],\n \"time\" => \"#{Time.at(reverse_lookup[\"t\"])}\"\n }\n end\n end\n\n #pash\n # Passive DNS history\n # TODO\n\n #acth\n # Active DNS history\n # TODO\n\n #as\n # Autonomous System Number\n if details[\"as\"]\n _create_entity \"AsNumber\",{\n \"name\" => \"AS#{details[\"as\"]}\",\n \"as_name\" => details[\"asname\"],\n \"as_desc\" => details[\"asdesc\"]\n }\n end\n\n # Netblock\n #\n if details[\"bgproute\"]\n _create_entity \"NetBlock\",{\"name\" => \"#{details[\"bgproute\"]}\"}\n end\n\n rescue JSON::ParserError => e\n _log_error \"Unable to get parsable response from #{search_uri}: #{e}\"\n rescue StandardError => e\n _log_error \"Error grabbing robtex details: #{e}\"\n end\n\n\n end",
"def index\n @apex_classes = sfdc_client.query \"SELECT Id, Name FROM ApexClass\"\n end",
"def list_thing(thing)\n next_marker = nil\n things = []\n loop do\n response = waf.send(\"list_#{thing}\", next_marker: next_marker, limit: 10)\n things += response.send(thing)\n next_marker = response.next_marker\n break unless next_marker\n end\n things\n end",
"def list_pokemons\n\n end",
"def list(*args)\n results = commit(\"list\", *args)\n Array(results).map do |result|\n self.class.new(connection, result)\n end\n end",
"def get_instances\n instances = [ ]\n get_clouds.each do |cloud|\n instances += cloud.instances.index(:filter => [], :view => 'tiny')\n end\n instances\n end",
"def list(resource_type,limit=0,params={})\n path = '/api/' + resource_type.to_s\n params.merge!({limit: limit.to_s})\n response = http_get(path,params)\n hydrate_list(resource_type, response['objects'])\n end",
"def index\n @announcaments = Announcament.all\n end",
"def list_instances_detail()\n response = dbreq(\"GET\", dbmgmthost, \"#{dbmgmtpath}/instances/detail\", dbmgmtport, dbmgmtscheme)\n CloudDB::Exception.raise_exception(response) unless response.code.to_s.match(/^20.$/)\n instances = CloudDB.symbolize_keys(JSON.parse(response.body)[\"instances\"])\n return instances\n end",
"def instance\n perform_request_with_object(:get, '/api/v1/instance', {}, Mastodon::Instance)\n end",
"def list request_pb, options = nil\n raise ::ArgumentError, \"request must be provided\" if request_pb.nil?\n\n verb, uri, query_string_params, body = ServiceStub.transcode_list_request request_pb\n query_string_params = if query_string_params.any?\n query_string_params.to_h { |p| p.split \"=\", 2 }\n else\n {}\n end\n\n response = @client_stub.make_http_request(\n verb,\n uri: uri,\n body: body || \"\",\n params: query_string_params,\n options: options\n )\n operation = ::Gapic::Rest::TransportOperation.new response\n result = ::Google::Cloud::Compute::V1::InstanceList.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def types\n @title = 'Resource Type Listing A-Z'\n @objects_by_letter = objects_by_letter(:puppet_type)\n erb(:objects)\nend",
"def instances\n unless defined? @instances then\n candidates = [ self.instances_path ]\n if configuration.instances then\n candidates = configuration.instances\n end\n\n @instances = {}\n while not candidates.empty? do\n candidate = candidates.pop\n cpath = append_to_home_if_not_absolute( candidate )\n begin\n t = TyrantInstance.new( cpath )\n t.manager = self\n @instances[t.name] = t\n rescue TyrantManager::Error => e\n if File.directory?( cpath ) then\n Dir.glob( \"#{cpath}/*\" ).each do |epath|\n if File.directory?( epath ) then\n candidates.push epath\n end\n end\n end\n end\n end #while \n end\n return @instances\n end",
"def list\n puts \"Here is a list of all the Voters!\"\n puts \"\"\n @voters.each do |voter|\n puts \"Voter: #{voter[:name]}, #{voter[:affiliation]}\"\n end\n puts \"Here is the list of all the Politicians!\"\n puts \"\"\n @politicians.each do |politician|\n puts \"Politician: #{politician[:name]}, #{politician[:affiliation]}\"\n end\n end",
"def list \n @people.each_with_index do |a,i|\n puts \"Entry \" + (i+1).to_s + \": \" + a.fullname\n end\n end",
"def list\n # For each of the possible contexts get the tags...\n context = params[:context] # context\n className = params[:class] # class\n exclude = params[:exclude]\n @results = nil\n \n op = exclude ? :match_all : :any\n query = ''\n if context.class == HashWithIndifferentAccess\n context.each do |key, ctx|\n query += \".tagged_with('\" + params[:tag][key] + \"', :on => '\" + ctx + \"', '+op+' => true)\"\n end\n end\n\n if isok(className)\n cl = eval(className) # get the instance of the class\n page = params[:page] ? params[:page].to_i : 1\n pagesize = params[:pagesize] ? params[:pagesize].to_i : 10\n\n # Allowed operations are any or match_all, if exclude has been passed then we assume an exact match...\n if query.empty?\n @results = Person.tagged_with(params[:tag], :on => context, op => true).by_last_name.paginate(:page => page, :per_page => pagesize)\n else\n @results = eval \"Person\" + query + \".by_last_name.paginate(:page => page, :per_page => pagesize)\"\n end\n end\n \n # 3. Then pass this along to the view\n respond_to do |format|\n format.html { render :layout => 'content' } # list.html.erb\n format.xml { render :xml => @results }\n end\n end",
"def call_all_apartments(ruby_apartments)\n ruby_apartments.each do |apartment|\n puts apartment.show_all_apartments\n end\nend",
"def load_blog_list\n resp = $ddb_client.scan({\n table_name: BLOGS_TABLE\n })\n\n p \"Scanned BlogTables ... found #{resp.length} blogs\"\n { items: resp.items, count: resp.count }\nend",
"def lookups; end"
] | [
"0.59593034",
"0.59593034",
"0.59511757",
"0.5877539",
"0.57154125",
"0.560014",
"0.55762017",
"0.55451024",
"0.55445963",
"0.55358726",
"0.5522449",
"0.5522449",
"0.5511502",
"0.5506903",
"0.54855984",
"0.54754263",
"0.5474711",
"0.5456025",
"0.54385316",
"0.5430289",
"0.5425914",
"0.54202425",
"0.5413084",
"0.53979313",
"0.53754646",
"0.53693277",
"0.53693277",
"0.53693277",
"0.5353712",
"0.5352276",
"0.5347016",
"0.5338623",
"0.5337904",
"0.5336033",
"0.53224283",
"0.5298819",
"0.5286015",
"0.5284017",
"0.527918",
"0.5277731",
"0.5273492",
"0.52702034",
"0.5269493",
"0.5267084",
"0.5256748",
"0.5245534",
"0.5242591",
"0.5228784",
"0.52172273",
"0.5209386",
"0.5206983",
"0.51997626",
"0.5199246",
"0.5197214",
"0.5196656",
"0.51946956",
"0.51781046",
"0.5170611",
"0.5169827",
"0.51696134",
"0.5166636",
"0.5160141",
"0.5160141",
"0.5160141",
"0.5160141",
"0.5160141",
"0.515606",
"0.5153931",
"0.51533276",
"0.51431704",
"0.5141604",
"0.5137454",
"0.5137454",
"0.5137454",
"0.5137454",
"0.51365405",
"0.513386",
"0.51254106",
"0.5121159",
"0.5119042",
"0.5118821",
"0.51174986",
"0.51140016",
"0.5113504",
"0.5103233",
"0.5098508",
"0.50974435",
"0.5090958",
"0.5087511",
"0.508158",
"0.5072567",
"0.5068389",
"0.5068289",
"0.5066087",
"0.5065446",
"0.50620633",
"0.5059879",
"0.5059389",
"0.5056832",
"0.50555754"
] | 0.57979727 | 4 |
Prepares the UID/GID settings for a single folder. | def prepare_permission(machine, perm, opts)
key = "map_#{perm}".to_sym
return nil if opts.has_key?(key) && opts[key].nil?
# The options on the hash get priority, then the default
# values
value = opts.has_key?(key) ? opts[key] : machine.config.nfs.send(key)
return value if value != :auto
# Get UID/GID from guests user if we've made it this far
# (value == :auto)
return machine.guest.capability("read_#{perm}".to_sym)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def folder_data\n @folder_data ||= Unan::folder_data + \"user/#{id}\"\n end",
"def nfs_opts_setup()\n @folders.each do |k, opts|\n if !opts[:linux__nfs_options]\n opts[:linux__nfs_options] ||= [\"rw\", \"no_subtree_check\", \"all_squash\", \"insecure\"]\n end\n\n # Only automatically set anonuid/anongid if they weren't\n # explicitly set by the user.\n hasgid = false\n hasuid = false\n opts[:linux__nfs_options].each do |opt|\n hasgid = !!(opt =~ /^anongid=/) if !hasgid\n hasuid = !!(opt =~ /^anonuid=/) if !hasuid\n end\n\n opts[:linux__nfs_options] << \"anonuid=#{opts[:map_uid]}\" if !hasuid\n opts[:linux__nfs_options] << \"anongid=#{opts[:map_gid]}\" if !hasgid\n opts[:linux__nfs_options] << \"fsid=#{opts[:uuid]}\"\n\n # Expand the guest path so we can handle things like \"~/vagrant\"\n expanded_guest_path = @machine.guest.capability(\n :shell_expand_guest_path, opts[:guestpath])\n\n # Do the actual creating and mounting\n @machine.communicate.sudo(\"mkdir -p #{expanded_guest_path}\")\n @machine.communicate.sudo(\"chown -R vagrant:vagrant #{expanded_guest_path}\")\n @machine.communicate.sudo(\"chmod u+rw #{expanded_guest_path}\")\n @machine.communicate.sudo(\"chmod g+rws #{expanded_guest_path}\")\n end\n end",
"def set_folder\n @folder = Folder.find_by!(id: params[:id], user_id: current_user.id)\n end",
"def prepare\n FileUtils.mkdir_p(@base_dir)\n end",
"def create_user_directories\n #Directories\n avatar = \"#{Rails.root}/data/avatars/#{resource.id}\"\n push = \"#{Rails.root}/data/push/#{resource.id}\"\n passes = \"#{Rails.root}/data/passes/#{resource.id}\"\n coredata = \"#{Rails.root}/data/coredata/#{resource.id}\"\n #Avatar Upload Pictures\n Dir.mkdir(avatar) unless File.exists?(avatar)\n #Push Notification Certificates\n Dir.mkdir(push) unless File.exists?(push)\n #Avatar Passbook\n Dir.mkdir(passes) unless File.exists?(passes)\n #Core Data\n Dir.mkdir(coredata) unless File.exists?(coredata)\n end",
"def set_uid\n unless gn.blank? || sn.blank?\n self['uid'] = gn.to_slug.approximate_ascii.normalize.to_s + '.' + sn.to_slug.approximate_ascii.normalize.to_s if uid.blank?\n end\n end",
"def set_folder\n @folder_id = params[:folder_id] ? params[:folder_id] : params[:id]\n unless @folder_id==\"#\"\n @folder = current_user.is_support? ? Folder.where(id: @folder_id).first : Folder.where(user_id: current_user.id, id: @folder_id).first\n\n params[:project_id] = @project_id = @folder.project_id\n @project = current_user.is_support? ? Project.where(id: @project_id).first : Project.where(user_id: current_user.id, id: @project_id).first unless @project\n end\n end",
"def test_mkdir_owner\n skip if !root?\n Scripto.mkdir(DIR, owner: \"nobody\")\n assert(Etc.getpwnam(\"nobody\").uid, File.stat(DIR).uid)\n end",
"def prepare\n FileUtils.rm_rf(@tempdirs, secure: true) if @tempdirs\n @tempdirs = []\n @base_options = nil\n @mode_options = nil\n @user_recipients = nil\n @user_keys = nil\n @system_identifiers = nil\n end",
"def setup subdirs\n FileUtils.mkdir_p @root\n if subdirs and subdirs.length > 0\n subdirs.each do |subdir|\n FileUtils.mkdir_p \"#{@root}#{@ds}#{subdir}\"\n end\n @subdirs = subdirs\n end\n end",
"def create_user_ingest_folder(user_name, parent = '0BxnZXCons72AYXZOTVVrdGk0bTg')\n metadata = @drive.files.insert.request_schema.new({\n 'title' => user_name,\n 'mimeType' => \"application/vnd.google-apps.folder\",\n 'parents' => [{'id' => parent}]\n })\n result = @client.execute( :api_method => @drive.files.insert, :body_object => metadata )\n result.data[\"id\"]\n end",
"def change_gid_and_uid(mythtv_storage_path, stream_ext)\n # Determine UID and GID of owner of the saved streams\n stream_glob = \"#{mythtv_storage_path}/*#{stream_ext}\"\n a_stream_fname = Dir[stream_glob][0]\n if !a_stream_fname\n\tputs \"!!! Could not find any recording at #{stream_glob}\"\n\texit 1\n end\n a_stream_stat = File.stat(a_stream_fname)\n mythtv_uid = a_stream_stat.uid\n mythtv_gid = a_stream_stat.gid\n if mythtv_gid != Process::Sys.getgid() ||\n\t mythtv_uid != Process::Sys.getuid()\n\tputs \"Changing #{stream_glob} to uid=#{mythtv_uid} gid=#{mythtv_gid}\" if $verbose\n\tProcess::Sys.setgid(mythtv_gid)\n\tProcess::Sys.setuid(mythtv_uid)\n end\nend",
"def init_folders(dir)\n\n FOLDER_DEFAULTS.each do |key|\n @folder=dir+\"/\"+key[:dir]\n @folder.gsub!('\\\\','/')\n if not File.directory? @folder\n File.makedirs @folder\n end\n end\n\n end",
"def initialize(config)\n super(config)\n @max_folder_depth = 20\n @implements_working_uidplus = true\n # unselectable parent folders are removed automatically\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def prepare_folders\n shared_folders.each do |_id, options|\n hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])\n\n next unless !hostpath.directory? && options[:create]\n # Host path doesn't exist, so let's create it.\n @logger.debug(\"Host path doesn't exist, creating: #{hostpath}\")\n\n begin\n hostpath.mkpath\n rescue Errno::EACCES\n raise Vagrant::Errors::SharedFolderCreateFailed,\n path: hostpath.to_s\n end\n end\n end",
"def unix_uid=(_arg0); end",
"def configuration_setup\n dirname = File.expand_path(USER_DIR)\n if !File.exists?(dirname)\n Dir.mkdir(dirname) \n create_storage_dir\n create_staging_dir\n create_user_conf_file\n create_user_email_conf_file\n else \n create_user_conf_file if !File.exists?(USER_CONF_FILE)\n create_storage_dir if !File.exists?(File.expand_path(STORAGE_DIR))\n create_staging_dir if !File.exists?(File.expand_path(STAGING_DIR))\n create_user_email_conf_file if !File.exists?(EMAIL_CONF_FILE)\n end\n end",
"def set_folder\n @folder = PulStore::Lae::Folder.find(params[:id])\n end",
"def setuid?() end",
"def set_default_user_and_group!(stats)\n stats[:uid] = 0\n stats[:gid] = 0\n end",
"def initialize(directory)\n p_dir = Pathname.new(directory)\n @nonce_dir = p_dir.join('nonces')\n @association_dir = p_dir.join('associations')\n @temp_dir = p_dir.join('temp')\n @auth_key_name = p_dir.join('auth_key')\n @max_nonce_age = 6 * 60 * 60\n \n self.ensure_dir(@nonce_dir)\n self.ensure_dir(@association_dir)\n self.ensure_dir(@temp_dir)\n self.ensure_dir(File.dirname(@auth_key_name))\n end",
"def set_up!\n return if set_up?\n settings.namespaces.each do |ns|\n path = make_path(ns)\n if !Dir.exists?(path) then\n settings.logger.debug(\"Creating dir #{path}\")\n FileUtils.mkdir_p(path)\n end\n end\n end",
"def root_dir=(_arg0); end",
"def root_folder_id\n self.root_folder\n end",
"def uid_file\n return nil if !@data_dir\n @data_dir.join(\"creator_uid\")\n end",
"def set_uid\n write_attribute('uid', self.uid)\n end",
"def initialize_root\n Utils.create_directory(@cache_root)\n Utils.clear_directory(@cache_root)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def set_FolderID(value)\n set_input(\"FolderID\", value)\n end",
"def userfolder\n # \"public/upload/user_id_\" + self.user_id.to_s\n User.find_by_id( self.user_id ).userfolder\n end",
"def prepare(directory, name = T.unsafe(nil)); end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def bootstrap\n puts \"Creating folder for project at #{folder}\"\n mkdir_p folder\n default_attributes\n save\n end",
"def set_owner\n user = @conf['user'] || Process.uid\n group = @conf['group'] || Process.gid\n\n begin\n FileUtils.chown_R(user, group, @location)\n rescue StandardError => err\n Pemlogger.logit(err, :fatal)\n raise(err)\n end\n end",
"def create_folder(folder_name, user_id)\n $db.execute(\"INSERT INTO folders (folder_name, owner_id) VALUES (?,?)\", folder_name, user_id)\nend",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def bootstrap_folder\n FileUtils.mkdir_p folder_path\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def set_folder\n @folder = Folder.find(params[:id])\n end",
"def prepare(machine, folders, opts)\n end",
"def initialize(primary_key, uuid, uti, note, backup)\n # Set this folder's variables\n super(primary_key, uuid, uti, note)\n\n # Gallery has no direct filename or path, just pointers to other pictures\n @filename = nil\n @filepath = nil\n @backup = backup\n\n # Add all the children\n add_gallery_children\n end",
"def set_directory\n @directory = Directory.find(params[:id])\n end",
"def script_settings_files_def\n {\n 'adjust_permissions.dirs' => {\n :uid => sftp_user_uid,\n :gid => group_gid,\n :reject_mmask => 0007 }\n }\nend",
"def test_setuid?\n assert_equal File.stat(@pp.to_s).setuid?, @pp.setuid?\n end",
"def make_home_directory( username, skeldir=SKELDIR )\n\t\tself.log.info \"Making home directory for %p, cloned from %s\" % [ username, skeldir ]\n\t\thomedir = HOMEDIR_BASE + username\n\t\traise \"%s: already exists\" % [ homedir ] if homedir.exist?\n\t\traise \"%s: already has an archived homedir\" % [ username ] if\n\t\t\t( ARCHIVE_BASE + username ).exist?\n\n\t\tFileUtils.cp_r( skeldir.to_s, homedir )\n\t\tFileUtils.chown_R( username, nil, homedir )\n\n\t\treturn homedir.to_s\n\tend",
"def dirname\n (uid.path.split(\".\") << \"#{timestamp}-#{random}\").join(\"/\")\n end",
"def initial_path_setup\n repo_name = @repo.repo_name.gsub(/[.]+/, '-') || @repo.repo_name\n repo_path = Rails.root.join('storage', 'repos', @repo.username, @repo.supplier_project_id.to_s, repo_name)\n FileUtils.mkdir_p(repo_path) unless File.directory?(repo_path)\n Dir.chdir(repo_path)\n ActiveRecord::Base.connection_pool.with_connection do \n @repo.update(clone_path: repo_path)\n end\n end",
"def generate_populate_folder\n empty_directory 'db/populate'\n # copy_file \"template_filename\", \"final_directory\" # With this we will copy the file straigh from tempaltes folder to the final destination\n # template \"template_filename\", \"final_directory\" # With this we can pass arguments to the template\n # if option_name ...\n end",
"def coerce_directories!\n @config.tap do |c|\n c.agency[:pid_directory] = path_from_env('SMITH_PID_DIRECTORY', c.agency[:pid_directory])\n c.agency[:cache_directory] = path_from_env('SMITH_CACHE_DIRECTORY', c.agency[:cache_directory])\n c.agency[:acl_directories] = paths_from_env('SMITH_ACL_DIRECTORIES', c.agency[:acl_directories])\n c.agency[:agent_directories] = paths_from_env('SMITH_AGENT_DIRECTORIES', c.agency[:agent_directories])\n end\n\n check_directories\n @config.agency[:acl_directories] = @config.agency[:acl_directories] + [smith_acl_directory]\n end",
"def setup_home_path\n\t\t\tsuper\n\n\t\t\tAWS_SUBDIRS.each do |dir|\n\t\t\t\tpath = aws_home_path.join(dir)\n\t\t\t\tnext if File.directory?(path)\n\t\t\t\t\n\t\t\t\tbegin\n\t\t\t\t\[email protected](\"Creating: #{dir}\")\n\t\t\t\t\tFileUtils.mkdir_p(path)\n\t\t\t\trescue Errno::EACCES\n\t\t\t\t\traise Errors::HomeDirectoryNotAccessible, :home_path\n\t\t\t\tend\n\t\t\tend\n\t\tend",
"def create_run_dir\n mkdir_run_user( run_dir, mode: run_dir_mode )\n end",
"def mkdir_run_user( dir, opts = {} )\n mode = opts[:mode] || 0775\n sudo \"mkdir -p #{dir}\"\n chown_run_user dir\n sudo( \"chmod %o %s\" % [ mode, dir ] )\n end",
"def parent_folder_id=(value)\n @parent_folder_id = value\n end",
"def init_existing\n return unless current_directory?\n\n FolderTree.for_path linked_path, root: directory, limit: folder_limit\n end",
"def gen_sub_directories\n\t\[email protected]\n\tend",
"def gen_sub_directories\n\t\[email protected]\n\tend",
"def setup_local_dirs\n File.makedirs Gift::GIFT_DIR unless File.exists?(Gift::GIFT_DIR)\n File.makedirs File.join(Gift::GIFT_DIR, Gift::DELIVERIES_DIR) unless File.exists?(File.join(Gift::GIFT_DIR, Gift::DELIVERIES_DIR))\n File.makedirs File.join(Gift::GIFT_DIR, Gift::DELIVERIES_DIR, self.id)\n end",
"def fixup_homedir_ownership(user)\n\t\t# Determine whether current ownership is right\n\t\thomedir_stat = File.stat(\"/home/#{user}/\")\n\n\t\tuid_correct =\n\t\t\t\tbegin\n\t\t\t\t\tEtc.getpwuid(homedir_stat.uid).name == user\n\t\t\t\trescue ArgumentError\n\t\t\t\t\tfalse\n\t\t\t\tend\n\t\tgid_correct =\n\t\t\t\tbegin\n\t\t\t\t\tEtc.getgrgid(homedir_stat.gid).name == user\n\t\t\t\trescue ArgumentError\n\t\t\t\t\tfalse\n\t\t\t\tend\n\n\t\tlogger.debug \"[CPB:restore] Attemping homedir permission fix.\" unless uid_correct and gid_correct\n\n\t\tunless uid_correct\n\t\t\tinvoke_and_log_cmd(\"/usr/bin/find -P /home/#{user}/ -user #{homedir_stat.uid} -exec /bin/chown -P --no-dereference #{user} '{}' \\\\;\", 'chown')\n\t\tend\n\n\t\tunless gid_correct\n\t\t\tinvoke_and_log_cmd(\"/usr/bin/find -P /home/#{user}/ -group #{homedir_stat.gid} -exec /bin/chgrp -P --no-dereference #{user} '{}' \\\\;\", 'chgrp')\n\t\tend\n\n\tend",
"def prepare_container_component_dirs; end",
"def camPrepareDir _obj, _args\n \"_obj camPrepareDir _args;\" \n end",
"def set_up_assignment_review\n set_up_defaults\n @assignment.directory_path = nil if @assignment.directory_path.empty?\n end",
"def set_data_dir\n @dir_val = SecureRandom.hex(32)\n while Study.where(data_dir: @dir_val).exists?\n @dir_val = SecureRandom.hex(32)\n end\n self.data_dir = @dir_val\n end",
"def uid=(p0) end",
"def prepare_dirs\n [@reports_dir, @cache_dir, @gems_dir].each do |dir|\n Dir.mkdir(dir) unless File.directory?(dir)\n end\n end",
"def root_dir\n 'gen_passwd'\n end",
"def unix_uid; end",
"def setup()\n create_directories\n end",
"def __build_folder(parent, entries, default_name)\n path = __build_path(entries)\n folder = parent.subfolders.find_by_path(path)\n folder ||= DbFolder.new(parent: parent, db: parent.db,\n path: path, name: default_name)\n # remove the id (if present) to mark this folder as updated\n @subfolder_ids -= [folder.id]\n # return the Updater, don't run it\n UpdateFolder.new(folder, entries)\n end",
"def set_temp_directory\n @base_theme_directory = 'public/temp/theme_1/'\n @temp_number = 1\n\n # Change value of @base_theme_directory until the folder name does not appear\n until !File.exist?(@base_theme_directory)\n @temp_number = @temp_number + 1\n @base_theme_directory = \"public/temp/theme_#{@temp_number.to_s}/\"\n end\n end",
"def initialize(*args)\n @folder = args.first[:folder] \n folder_handler(@folder) # create folder if necessary\n @logger = {}\n end",
"def initialize(root_folder)\n @root_folder = root_folder\n end",
"def create\r\n if request.post?\r\n @folder = Folder.new(params[:folder])\r\n @folder.parent_id = folder_id\r\n @folder.date_modified = Time.now\r\n @folder.user = @logged_in_user\r\n\r\n if @folder.save\r\n # copy groups rights on parent folder to new folder\r\n copy_permissions_to_new_folder(@folder)\r\n\r\n # back to the list\r\n redirect_to :action => 'list', :id => params[:id]\r\n else\r\n render_action 'new'\r\n end\r\n end\r\n end",
"def set_user_file\n @user_file = @folder.files.find(params[:id])\n end",
"def initialize(config)\n super(config)\n @standard_folders[:Trash] = \"[Google Mail]/Trash\"\n @standard_folders[:Drafts] = \"[Google Mail]/Drafts\"\n @standard_folders[:Sent] = \"[Google Mail]/Sent Mail\"\n @max_folder_depth = 8\n # unselectable parent folders are removed automatically\n end",
"def _io_user_data(username)\n (node['etc'] && node['etc']['passwd'] && node['etc']['passwd'][username]) || {\n 'uid' => username,\n 'gid' => username,\n 'dir' => \"/home/#{username}\"\n }\nend",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def base_dir=(_arg0); end",
"def import_folder! folder\n end"
] | [
"0.6155748",
"0.591959",
"0.5774387",
"0.574445",
"0.56300026",
"0.55959296",
"0.5515075",
"0.54770964",
"0.54734045",
"0.54668486",
"0.545837",
"0.5449234",
"0.5424296",
"0.5412621",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5410193",
"0.5353062",
"0.53370506",
"0.52996683",
"0.52959806",
"0.5262685",
"0.5247036",
"0.52317846",
"0.5230562",
"0.52251655",
"0.52189195",
"0.52120495",
"0.5180621",
"0.5156355",
"0.515341",
"0.515341",
"0.515341",
"0.515341",
"0.515341",
"0.51381373",
"0.5128528",
"0.51277494",
"0.51277494",
"0.51277494",
"0.51277494",
"0.51277494",
"0.5105862",
"0.50839573",
"0.5078072",
"0.5076907",
"0.50736886",
"0.5068273",
"0.5068273",
"0.50672406",
"0.50519073",
"0.503596",
"0.50277007",
"0.5011756",
"0.50094795",
"0.5008863",
"0.5008449",
"0.4993421",
"0.49873242",
"0.49814528",
"0.4978814",
"0.49725717",
"0.49712816",
"0.49704787",
"0.49613592",
"0.49613592",
"0.4955698",
"0.49521288",
"0.49427372",
"0.49406236",
"0.49389067",
"0.49388164",
"0.4933608",
"0.4921153",
"0.49210656",
"0.4917399",
"0.49140385",
"0.49139282",
"0.4893685",
"0.48867473",
"0.48822764",
"0.48816112",
"0.48642558",
"0.4863843",
"0.48529524",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48503098",
"0.48440102"
] | 0.0 | -1 |
I can't decide whether this is clever or really dirty just to satisfy authorities_service_spec.rb Pros: It is a legitimate comparison for this object in its current conception. Cons: makes the code slightly less maintainable and harder to extend extra thing to think about if this object needs to be changed. | def == other_authority
same_name_and_id = @name == other_authority.name && @id == other_authority.id
unless (@filename.nil? && other_authority.filename.nil?)
return same_name_and_id && @filename == other_authority.filename
end
same_name_and_id
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n access_token_strategy == o.access_token_strategy &&\n allowed_cors_origins == o.allowed_cors_origins &&\n audience == o.audience &&\n authorization_code_grant_access_token_lifespan == o.authorization_code_grant_access_token_lifespan &&\n authorization_code_grant_id_token_lifespan == o.authorization_code_grant_id_token_lifespan &&\n authorization_code_grant_refresh_token_lifespan == o.authorization_code_grant_refresh_token_lifespan &&\n backchannel_logout_session_required == o.backchannel_logout_session_required &&\n backchannel_logout_uri == o.backchannel_logout_uri &&\n client_credentials_grant_access_token_lifespan == o.client_credentials_grant_access_token_lifespan &&\n client_id == o.client_id &&\n client_name == o.client_name &&\n client_secret == o.client_secret &&\n client_secret_expires_at == o.client_secret_expires_at &&\n client_uri == o.client_uri &&\n contacts == o.contacts &&\n created_at == o.created_at &&\n frontchannel_logout_session_required == o.frontchannel_logout_session_required &&\n frontchannel_logout_uri == o.frontchannel_logout_uri &&\n grant_types == o.grant_types &&\n implicit_grant_access_token_lifespan == o.implicit_grant_access_token_lifespan &&\n implicit_grant_id_token_lifespan == o.implicit_grant_id_token_lifespan &&\n jwks == o.jwks &&\n jwks_uri == o.jwks_uri &&\n jwt_bearer_grant_access_token_lifespan == o.jwt_bearer_grant_access_token_lifespan &&\n logo_uri == o.logo_uri &&\n metadata == o.metadata &&\n owner == o.owner &&\n policy_uri == o.policy_uri &&\n post_logout_redirect_uris == o.post_logout_redirect_uris &&\n redirect_uris == o.redirect_uris &&\n refresh_token_grant_access_token_lifespan == o.refresh_token_grant_access_token_lifespan &&\n refresh_token_grant_id_token_lifespan == o.refresh_token_grant_id_token_lifespan &&\n refresh_token_grant_refresh_token_lifespan == o.refresh_token_grant_refresh_token_lifespan &&\n registration_access_token == o.registration_access_token &&\n registration_client_uri == o.registration_client_uri &&\n request_object_signing_alg == o.request_object_signing_alg &&\n request_uris == o.request_uris &&\n response_types == o.response_types &&\n scope == o.scope &&\n sector_identifier_uri == o.sector_identifier_uri &&\n skip_consent == o.skip_consent &&\n subject_type == o.subject_type &&\n token_endpoint_auth_method == o.token_endpoint_auth_method &&\n token_endpoint_auth_signing_alg == o.token_endpoint_auth_signing_alg &&\n tos_uri == o.tos_uri &&\n updated_at == o.updated_at &&\n userinfo_signed_response_alg == o.userinfo_signed_response_alg\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n identifier == o.identifier &&\n name == o.name &&\n status == o.status &&\n type == o.type &&\n address_line1 == o.address_line1 &&\n address_line2 == o.address_line2 &&\n city == o.city &&\n state == o.state &&\n zip == o.zip &&\n country == o.country &&\n phone_number == o.phone_number &&\n fax_number == o.fax_number &&\n website == o.website &&\n territory_id == o.territory_id &&\n market_id == o.market_id &&\n account_number == o.account_number &&\n default_contact == o.default_contact &&\n date_acquired == o.date_acquired &&\n sic_code == o.sic_code &&\n parent_company == o.parent_company &&\n annual_revenue == o.annual_revenue &&\n number_of_employees == o.number_of_employees &&\n ownership_type == o.ownership_type &&\n time_zone == o.time_zone &&\n lead_source == o.lead_source &&\n lead_flag == o.lead_flag &&\n unsubscribe_flag == o.unsubscribe_flag &&\n calendar_id == o.calendar_id &&\n user_defined_field1 == o.user_defined_field1 &&\n user_defined_field2 == o.user_defined_field2 &&\n user_defined_field3 == o.user_defined_field3 &&\n user_defined_field4 == o.user_defined_field4 &&\n user_defined_field5 == o.user_defined_field5 &&\n user_defined_field6 == o.user_defined_field6 &&\n user_defined_field7 == o.user_defined_field7 &&\n user_defined_field8 == o.user_defined_field8 &&\n user_defined_field9 == o.user_defined_field9 &&\n user_defined_field10 == o.user_defined_field10 &&\n deleted_flag == o.deleted_flag &&\n date_deleted == o.date_deleted &&\n deleted_by == o.deleted_by &&\n mobile_guid == o.mobile_guid &&\n currency == o.currency &&\n _info == o._info &&\n custom_fields == o.custom_fields\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n access == o.access &&\n admin_url == o.admin_url &&\n always_display_in_console == o.always_display_in_console &&\n attributes == o.attributes &&\n authentication_flow_binding_overrides == o.authentication_flow_binding_overrides &&\n authorization_services_enabled == o.authorization_services_enabled &&\n authorization_settings == o.authorization_settings &&\n base_url == o.base_url &&\n bearer_only == o.bearer_only &&\n client_authenticator_type == o.client_authenticator_type &&\n client_id == o.client_id &&\n consent_required == o.consent_required &&\n default_client_scopes == o.default_client_scopes &&\n default_roles == o.default_roles &&\n description == o.description &&\n direct_access_grants_enabled == o.direct_access_grants_enabled &&\n enabled == o.enabled &&\n frontchannel_logout == o.frontchannel_logout &&\n full_scope_allowed == o.full_scope_allowed &&\n id == o.id &&\n implicit_flow_enabled == o.implicit_flow_enabled &&\n name == o.name &&\n node_re_registration_timeout == o.node_re_registration_timeout &&\n not_before == o.not_before &&\n optional_client_scopes == o.optional_client_scopes &&\n origin == o.origin &&\n protocol == o.protocol &&\n protocol_mappers == o.protocol_mappers &&\n public_client == o.public_client &&\n redirect_uris == o.redirect_uris &&\n registered_nodes == o.registered_nodes &&\n registration_access_token == o.registration_access_token &&\n root_url == o.root_url &&\n secret == o.secret &&\n service_accounts_enabled == o.service_accounts_enabled &&\n standard_flow_enabled == o.standard_flow_enabled &&\n surrogate_auth_required == o.surrogate_auth_required &&\n web_origins == o.web_origins\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n created == o.created &&\n changed_by == o.changed_by &&\n updated == o.updated &&\n metadata == o.metadata &&\n id == o.id &&\n version_id == o.version_id &&\n crm_id == o.crm_id &&\n account_id == o.account_id &&\n organization_id == o.organization_id &&\n product_id == o.product_id &&\n product_rate_plan_id == o.product_rate_plan_id &&\n parent_id == o.parent_id &&\n name == o.name &&\n description == o.description &&\n type == o.type &&\n state == o.state &&\n current_period_start == o.current_period_start &&\n current_period_end == o.current_period_end &&\n contract_start == o.contract_start &&\n subscription_end == o.subscription_end &&\n current_period_end_explicit == o.current_period_end_explicit &&\n initial_period_start == o.initial_period_start &&\n successful_periods == o.successful_periods &&\n total_periods == o.total_periods &&\n trial_end == o.trial_end &&\n dunning == o.dunning &&\n locked == o.locked &&\n managed_by == o.managed_by &&\n version_start == o.version_start &&\n version_end == o.version_end &&\n version_number == o.version_number &&\n credit_enabled == o.credit_enabled &&\n aggregate_all_subscriptions_on_account == o.aggregate_all_subscriptions_on_account &&\n pricing_component_values == o.pricing_component_values &&\n payment_method_subscription_links == o.payment_method_subscription_links &&\n fixed_terms == o.fixed_terms &&\n current_time == o.current_time &&\n time_offset == o.time_offset &&\n payment_terms == o.payment_terms &&\n purchase_order == o.purchase_order &&\n failed_payment_behaviour == o.failed_payment_behaviour\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n client_id == o.client_id &&\n secret == o.secret &&\n client_name == o.client_name &&\n language == o.language &&\n country_codes == o.country_codes &&\n user == o.user &&\n products == o.products &&\n additional_consented_products == o.additional_consented_products &&\n required_if_supported_products == o.required_if_supported_products &&\n webhook == o.webhook &&\n access_token == o.access_token &&\n link_customization_name == o.link_customization_name &&\n redirect_uri == o.redirect_uri &&\n android_package_name == o.android_package_name &&\n institution_data == o.institution_data &&\n account_filters == o.account_filters &&\n eu_config == o.eu_config &&\n institution_id == o.institution_id &&\n payment_initiation == o.payment_initiation &&\n deposit_switch == o.deposit_switch &&\n employment == o.employment &&\n income_verification == o.income_verification &&\n base_report == o.base_report &&\n consumer_report_permissible_purpose == o.consumer_report_permissible_purpose &&\n auth == o.auth &&\n transfer == o.transfer &&\n update == o.update &&\n identity_verification == o.identity_verification &&\n statements == o.statements &&\n user_token == o.user_token &&\n investments == o.investments &&\n investments_auth == o.investments_auth &&\n hosted_link == o.hosted_link\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account_id == o.account_id &&\n account_service_ids == o.account_service_ids &&\n address == o.address &&\n api_key == o.api_key &&\n city == o.city &&\n code == o.code &&\n country == o.country &&\n create_time == o.create_time &&\n created_by_email == o.created_by_email &&\n created_by_id == o.created_by_id &&\n delete_time == o.delete_time &&\n email == o.email &&\n enabled == o.enabled &&\n first_name == o.first_name &&\n id == o.id &&\n is_main_user == o.is_main_user &&\n last_launched_test_time == o.last_launched_test_time &&\n last_login_time == o.last_login_time &&\n last_name == o.last_name &&\n main_user_email == o.main_user_email &&\n main_user_id == o.main_user_id &&\n mfa_qr_code_url == o.mfa_qr_code_url &&\n mfa_status == o.mfa_status &&\n organization == o.organization &&\n origin_portal == o.origin_portal &&\n phone == o.phone &&\n registration_ip == o.registration_ip &&\n roles == o.roles &&\n self_uri == o.self_uri &&\n service_ids == o.service_ids &&\n state == o.state &&\n status == o.status &&\n time_zone == o.time_zone &&\n vat_id == o.vat_id\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n authorization_endpoint == o.authorization_endpoint &&\n backchannel_logout_session_supported == o.backchannel_logout_session_supported &&\n backchannel_logout_supported == o.backchannel_logout_supported &&\n claims_parameter_supported == o.claims_parameter_supported &&\n claims_supported == o.claims_supported &&\n code_challenge_methods_supported == o.code_challenge_methods_supported &&\n credentials_endpoint_draft_00 == o.credentials_endpoint_draft_00 &&\n credentials_supported_draft_00 == o.credentials_supported_draft_00 &&\n end_session_endpoint == o.end_session_endpoint &&\n frontchannel_logout_session_supported == o.frontchannel_logout_session_supported &&\n frontchannel_logout_supported == o.frontchannel_logout_supported &&\n grant_types_supported == o.grant_types_supported &&\n id_token_signed_response_alg == o.id_token_signed_response_alg &&\n id_token_signing_alg_values_supported == o.id_token_signing_alg_values_supported &&\n issuer == o.issuer &&\n jwks_uri == o.jwks_uri &&\n registration_endpoint == o.registration_endpoint &&\n request_object_signing_alg_values_supported == o.request_object_signing_alg_values_supported &&\n request_parameter_supported == o.request_parameter_supported &&\n request_uri_parameter_supported == o.request_uri_parameter_supported &&\n require_request_uri_registration == o.require_request_uri_registration &&\n response_modes_supported == o.response_modes_supported &&\n response_types_supported == o.response_types_supported &&\n revocation_endpoint == o.revocation_endpoint &&\n scopes_supported == o.scopes_supported &&\n subject_types_supported == o.subject_types_supported &&\n token_endpoint == o.token_endpoint &&\n token_endpoint_auth_methods_supported == o.token_endpoint_auth_methods_supported &&\n userinfo_endpoint == o.userinfo_endpoint &&\n userinfo_signed_response_alg == o.userinfo_signed_response_alg &&\n userinfo_signing_alg_values_supported == o.userinfo_signing_alg_values_supported\n end",
"def compare_by_identity\n raise NotImplementedError\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n accounting == o.accounting &&\n amember == o.amember &&\n auto_order == o.auto_order &&\n ccbill == o.ccbill &&\n channel_partner_item_mappings == o.channel_partner_item_mappings &&\n chargeback == o.chargeback &&\n checkout == o.checkout &&\n content == o.content &&\n creation_dts == o.creation_dts &&\n description == o.description &&\n description_translated_text_instance_oid == o.description_translated_text_instance_oid &&\n digital_delivery == o.digital_delivery &&\n ebay == o.ebay &&\n email_notifications == o.email_notifications &&\n enrollment123 == o.enrollment123 &&\n fulfillment_addons == o.fulfillment_addons &&\n gift_certificate == o.gift_certificate &&\n google_product_search == o.google_product_search &&\n identifiers == o.identifiers &&\n inactive == o.inactive &&\n instant_payment_notifications == o.instant_payment_notifications &&\n internal == o.internal &&\n kit == o.kit &&\n kit_component_only == o.kit_component_only &&\n kit_definition == o.kit_definition &&\n last_modified_dts == o.last_modified_dts &&\n merchant_id == o.merchant_id &&\n merchant_item_id == o.merchant_item_id &&\n merchant_item_oid == o.merchant_item_oid &&\n options == o.options &&\n parent_category_id == o.parent_category_id &&\n parent_category_path == o.parent_category_path &&\n payment_processing == o.payment_processing &&\n physical == o.physical &&\n pricing == o.pricing &&\n properties == o.properties &&\n realtime_pricing == o.realtime_pricing &&\n recommend_replenishment_days == o.recommend_replenishment_days &&\n related == o.related &&\n reporting == o.reporting &&\n restriction == o.restriction &&\n revguard == o.revguard &&\n reviews == o.reviews &&\n salesforce == o.salesforce &&\n shipping == o.shipping &&\n tags == o.tags &&\n tax == o.tax &&\n third_party_email_marketing == o.third_party_email_marketing &&\n variant_items == o.variant_items &&\n variations == o.variations &&\n wishlist_member == o.wishlist_member\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account_management_granular == o.account_management_granular &&\n admin_only == o.admin_only &&\n admin_only_metadata == o.admin_only_metadata &&\n allow_auto_tagging == o.allow_auto_tagging &&\n allow_envelope_transfer_to == o.allow_envelope_transfer_to &&\n allow_envelope_transfer_to_metadata == o.allow_envelope_transfer_to_metadata &&\n allow_eseal_recipients == o.allow_eseal_recipients &&\n allow_eseal_recipients_metadata == o.allow_eseal_recipients_metadata &&\n allow_power_forms_admin_to_access_all_power_form_envelope == o.allow_power_forms_admin_to_access_all_power_form_envelope &&\n allow_power_forms_admin_to_access_all_power_form_envelope_metadata == o.allow_power_forms_admin_to_access_all_power_form_envelope_metadata &&\n allow_recipient_language_selection == o.allow_recipient_language_selection &&\n allow_recipient_language_selection_metadata == o.allow_recipient_language_selection_metadata &&\n allow_send_on_behalf_of == o.allow_send_on_behalf_of &&\n allow_send_on_behalf_of_metadata == o.allow_send_on_behalf_of_metadata &&\n allow_supplemental_documents == o.allow_supplemental_documents &&\n allow_supplemental_documents_metadata == o.allow_supplemental_documents_metadata &&\n anchor_tag_versioned_placement_enabled == o.anchor_tag_versioned_placement_enabled &&\n api_account_wide_access == o.api_account_wide_access &&\n api_account_wide_access_metadata == o.api_account_wide_access_metadata &&\n api_can_export_ac == o.api_can_export_ac &&\n api_can_export_ac_metadata == o.api_can_export_ac_metadata &&\n bulk_send == o.bulk_send &&\n bulk_send_metadata == o.bulk_send_metadata &&\n can_charge_account == o.can_charge_account &&\n can_charge_account_metadata == o.can_charge_account_metadata &&\n can_edit_shared_addressbook == o.can_edit_shared_addressbook &&\n can_edit_shared_addressbook_metadata == o.can_edit_shared_addressbook_metadata &&\n can_lock_envelopes == o.can_lock_envelopes &&\n can_lock_envelopes_metadata == o.can_lock_envelopes_metadata &&\n can_manage_account == o.can_manage_account &&\n can_manage_account_metadata == o.can_manage_account_metadata &&\n can_manage_distributor == o.can_manage_distributor &&\n can_manage_distributor_metadata == o.can_manage_distributor_metadata &&\n can_manage_templates == o.can_manage_templates &&\n can_manage_templates_metadata == o.can_manage_templates_metadata &&\n can_send_api_requests == o.can_send_api_requests &&\n can_send_api_requests_metadata == o.can_send_api_requests_metadata &&\n can_send_envelope == o.can_send_envelope &&\n can_send_envelope_metadata == o.can_send_envelope_metadata &&\n can_sign_envelope == o.can_sign_envelope &&\n can_sign_envelope_metadata == o.can_sign_envelope_metadata &&\n can_use_scratchpad == o.can_use_scratchpad &&\n can_use_scratchpad_metadata == o.can_use_scratchpad_metadata &&\n can_use_smart_contracts == o.can_use_smart_contracts &&\n can_use_smart_contracts_metadata == o.can_use_smart_contracts_metadata &&\n disable_document_upload == o.disable_document_upload &&\n disable_document_upload_metadata == o.disable_document_upload_metadata &&\n disable_other_actions == o.disable_other_actions &&\n disable_other_actions_metadata == o.disable_other_actions_metadata &&\n enable_ds_pro == o.enable_ds_pro &&\n enable_ds_pro_metadata == o.enable_ds_pro_metadata &&\n enable_sequential_signing_api == o.enable_sequential_signing_api &&\n enable_sequential_signing_api_metadata == o.enable_sequential_signing_api_metadata &&\n enable_sequential_signing_ui == o.enable_sequential_signing_ui &&\n enable_sequential_signing_ui_metadata == o.enable_sequential_signing_ui_metadata &&\n enable_signer_attachments == o.enable_signer_attachments &&\n enable_signer_attachments_metadata == o.enable_signer_attachments_metadata &&\n enable_sign_on_paper_override == o.enable_sign_on_paper_override &&\n enable_sign_on_paper_override_metadata == o.enable_sign_on_paper_override_metadata &&\n enable_transaction_point == o.enable_transaction_point &&\n enable_transaction_point_metadata == o.enable_transaction_point_metadata &&\n enable_vaulting == o.enable_vaulting &&\n enable_vaulting_metadata == o.enable_vaulting_metadata &&\n express_send_only == o.express_send_only &&\n locale == o.locale &&\n locale_metadata == o.locale_metadata &&\n locale_policy == o.locale_policy &&\n manage_clickwraps_mode == o.manage_clickwraps_mode &&\n manage_clickwraps_mode_metadata == o.manage_clickwraps_mode_metadata &&\n modified_by == o.modified_by &&\n modified_by_metadata == o.modified_by_metadata &&\n modified_date == o.modified_date &&\n modified_date_metadata == o.modified_date_metadata &&\n modified_page == o.modified_page &&\n modified_page_metadata == o.modified_page_metadata &&\n new_send_ui == o.new_send_ui &&\n new_send_ui_metadata == o.new_send_ui_metadata &&\n power_form_mode == o.power_form_mode &&\n power_form_mode_metadata == o.power_form_mode_metadata &&\n recipient_viewed_notification == o.recipient_viewed_notification &&\n recipient_viewed_notification_metadata == o.recipient_viewed_notification_metadata &&\n seal_identifiers == o.seal_identifiers &&\n self_signed_recipient_email_document == o.self_signed_recipient_email_document &&\n self_signed_recipient_email_document_metadata == o.self_signed_recipient_email_document_metadata &&\n sender_email_notifications == o.sender_email_notifications &&\n signer_email_notifications == o.signer_email_notifications &&\n supplemental_document_include_in_download == o.supplemental_document_include_in_download &&\n supplemental_documents_must_accept == o.supplemental_documents_must_accept &&\n supplemental_documents_must_accept_metadata == o.supplemental_documents_must_accept_metadata &&\n supplemental_documents_must_read == o.supplemental_documents_must_read &&\n supplemental_documents_must_read_metadata == o.supplemental_documents_must_read_metadata &&\n supplemental_documents_must_view == o.supplemental_documents_must_view &&\n supplemental_documents_must_view_metadata == o.supplemental_documents_must_view_metadata &&\n template_active_creation == o.template_active_creation &&\n template_active_creation_metadata == o.template_active_creation_metadata &&\n template_apply_notify == o.template_apply_notify &&\n template_apply_notify_metadata == o.template_apply_notify_metadata &&\n template_auto_matching == o.template_auto_matching &&\n template_auto_matching_metadata == o.template_auto_matching_metadata &&\n template_matching_sensitivity == o.template_matching_sensitivity &&\n template_matching_sensitivity_metadata == o.template_matching_sensitivity_metadata &&\n template_page_level_matching == o.template_page_level_matching &&\n template_page_level_matching_metadata == o.template_page_level_matching_metadata &&\n timezone_dst == o.timezone_dst &&\n timezone_dst_metadata == o.timezone_dst_metadata &&\n timezone_mask == o.timezone_mask &&\n timezone_mask_metadata == o.timezone_mask_metadata &&\n timezone_offset == o.timezone_offset &&\n timezone_offset_metadata == o.timezone_offset_metadata &&\n timezone_sending_pref == o.timezone_sending_pref &&\n timezone_sending_pref_metadata == o.timezone_sending_pref_metadata &&\n timezone_signing_pref == o.timezone_signing_pref &&\n timezone_signing_pref_metadata == o.timezone_signing_pref_metadata &&\n transaction_point_site_name_url == o.transaction_point_site_name_url &&\n transaction_point_site_name_url_metadata == o.transaction_point_site_name_url_metadata &&\n transaction_point_user_name == o.transaction_point_user_name &&\n transaction_point_user_name_metadata == o.transaction_point_user_name_metadata &&\n vaulting_mode == o.vaulting_mode &&\n vaulting_mode_metadata == o.vaulting_mode_metadata\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n token == o.token &&\n active == o.active &&\n notes == o.notes &&\n ip_address == o.ip_address &&\n password == o.password &&\n phone == o.phone &&\n metadata == o.metadata &&\n account_holder_group_token == o.account_holder_group_token &&\n identifications == o.identifications &&\n business_name_legal == o.business_name_legal &&\n business_name_dba == o.business_name_dba &&\n office_location == o.office_location &&\n in_current_location_since == o.in_current_location_since &&\n website == o.website &&\n date_established == o.date_established &&\n general_business_description == o.general_business_description &&\n history == o.history &&\n business_type == o.business_type &&\n international_office_locations == o.international_office_locations &&\n taxpayer_id == o.taxpayer_id &&\n duns_number == o.duns_number &&\n primary_contact == o.primary_contact &&\n incorporation == o.incorporation &&\n proprietor_or_officer == o.proprietor_or_officer &&\n beneficial_owner1 == o.beneficial_owner1 &&\n beneficial_owner2 == o.beneficial_owner2 &&\n beneficial_owner3 == o.beneficial_owner3 &&\n beneficial_owner4 == o.beneficial_owner4 &&\n attester_name == o.attester_name &&\n attestation_consent == o.attestation_consent &&\n attester_title == o.attester_title &&\n attestation_date == o.attestation_date &&\n proprietor_is_beneficial_owner == o.proprietor_is_beneficial_owner\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n identifier == o.identifier &&\n password == o.password &&\n first_name == o.first_name &&\n middle_initial == o.middle_initial &&\n last_name == o.last_name &&\n title == o.title &&\n report_card == o.report_card &&\n license_class == o.license_class &&\n disable_online_flag == o.disable_online_flag &&\n enable_mobile_flag == o.enable_mobile_flag &&\n type == o.type &&\n employee_identifer == o.employee_identifer &&\n vendor_number == o.vendor_number &&\n notes == o.notes &&\n time_zone == o.time_zone &&\n country == o.country &&\n service_board_team_ids == o.service_board_team_ids &&\n enable_mobile_gps_flag == o.enable_mobile_gps_flag &&\n inactive_date == o.inactive_date &&\n inactive_flag == o.inactive_flag &&\n last_login == o.last_login &&\n photo == o.photo &&\n office_email == o.office_email &&\n office_phone == o.office_phone &&\n office_extension == o.office_extension &&\n mobile_email == o.mobile_email &&\n mobile_phone == o.mobile_phone &&\n mobile_extension == o.mobile_extension &&\n home_email == o.home_email &&\n home_phone == o.home_phone &&\n home_extension == o.home_extension &&\n default_email == o.default_email &&\n default_phone == o.default_phone &&\n security_role == o.security_role &&\n admin_flag == o.admin_flag &&\n structure_level == o.structure_level &&\n security_location == o.security_location &&\n default_location == o.default_location &&\n default_department == o.default_department &&\n reports_to == o.reports_to &&\n restrict_location_flag == o.restrict_location_flag &&\n restrict_department_flag == o.restrict_department_flag &&\n work_role == o.work_role &&\n work_type == o.work_type &&\n time_approver == o.time_approver &&\n expense_approver == o.expense_approver &&\n billable_forecast == o.billable_forecast &&\n daily_capacity == o.daily_capacity &&\n hourly_cost == o.hourly_cost &&\n hourly_rate == o.hourly_rate &&\n include_in_utilization_reporting_flag == o.include_in_utilization_reporting_flag &&\n require_expense_entry_flag == o.require_expense_entry_flag &&\n require_time_sheet_entry_flag == o.require_time_sheet_entry_flag &&\n require_start_and_end_time_on_time_entry_flag == o.require_start_and_end_time_on_time_entry_flag &&\n allow_in_cell_entry_on_time_sheet == o.allow_in_cell_entry_on_time_sheet &&\n enter_time_against_company_flag == o.enter_time_against_company_flag &&\n allow_expenses_entered_against_companies_flag == o.allow_expenses_entered_against_companies_flag &&\n time_reminder_email_flag == o.time_reminder_email_flag &&\n days_tolerance == o.days_tolerance &&\n minimum_hours == o.minimum_hours &&\n time_sheet_start_date == o.time_sheet_start_date &&\n hire_date == o.hire_date &&\n service_default_location == o.service_default_location &&\n service_default_department == o.service_default_department &&\n service_default_board == o.service_default_board &&\n restrict_service_default_location_flag == o.restrict_service_default_location_flag &&\n restrict_service_default_department_flag == o.restrict_service_default_department_flag &&\n excluded_service_board_ids == o.excluded_service_board_ids &&\n project_default_location == o.project_default_location &&\n project_default_department == o.project_default_department &&\n project_default_board == o.project_default_board &&\n restrict_project_default_location_flag == o.restrict_project_default_location_flag &&\n restrict_project_default_department_flag == o.restrict_project_default_department_flag &&\n excluded_project_board_ids == o.excluded_project_board_ids &&\n schedule_default_location == o.schedule_default_location &&\n schedule_default_department == o.schedule_default_department &&\n schedule_capacity == o.schedule_capacity &&\n service_location == o.service_location &&\n restrict_schedule_flag == o.restrict_schedule_flag &&\n hide_member_in_dispatch_portal_flag == o.hide_member_in_dispatch_portal_flag &&\n calendar == o.calendar &&\n sales_default_location == o.sales_default_location &&\n restrict_default_sales_territory_flag == o.restrict_default_sales_territory_flag &&\n warehouse == o.warehouse &&\n warehouse_bin == o.warehouse_bin &&\n restrict_default_warehouse_flag == o.restrict_default_warehouse_flag &&\n restrict_default_warehouse_bin_flag == o.restrict_default_warehouse_bin_flag &&\n mapi_name == o.mapi_name &&\n calendar_sync_integration_flag == o.calendar_sync_integration_flag &&\n enable_ldap_authentication_flag == o.enable_ldap_authentication_flag &&\n ldap_configuration == o.ldap_configuration &&\n ldap_user_name == o.ldap_user_name &&\n company_activity_tab_format == o.company_activity_tab_format &&\n invoice_time_tab_format == o.invoice_time_tab_format &&\n invoice_screen_default_tab_format == o.invoice_screen_default_tab_format &&\n invoicing_display_options == o.invoicing_display_options &&\n agreement_invoicing_display_options == o.agreement_invoicing_display_options &&\n corelytics_username == o.corelytics_username &&\n corelytics_password == o.corelytics_password &&\n remote_package == o.remote_package &&\n remote_package_platform == o.remote_package_platform &&\n remote_package_user_name == o.remote_package_user_name &&\n remote_package_password == o.remote_package_password &&\n remote_package_account == o.remote_package_account &&\n authentication_service_type == o.authentication_service_type &&\n timebased_one_time_password_activated == o.timebased_one_time_password_activated &&\n _info == o._info\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n type == o.type &&\n state == o.state &&\n country == o.country &&\n street == o.street &&\n postal_code == o.postal_code &&\n city == o.city &&\n phone_country == o.phone_country &&\n phone_number == o.phone_number &&\n email == o.email &&\n ip == o.ip &&\n address_description == o.address_description &&\n identification_number == o.identification_number &&\n identification_type == o.identification_type &&\n lang == o.lang &&\n name == o.name &&\n first_name == o.first_name &&\n middle_name == o.middle_name &&\n last_name == o.last_name &&\n birth_date == o.birth_date &&\n occupation == o.occupation &&\n nationality == o.nationality &&\n legal_entity_type == o.legal_entity_type &&\n registration_date == o.registration_date &&\n registration_number == o.registration_number &&\n nature_of_business == o.nature_of_business &&\n source_of_funds == o.source_of_funds &&\n custom_source_of_funds == o.custom_source_of_funds &&\n core_business_activity == o.core_business_activity &&\n purpose_of_opening_account == o.purpose_of_opening_account &&\n office_phone == o.office_phone &&\n vat_registration_number == o.vat_registration_number &&\n financial_regulator == o.financial_regulator &&\n regulatory_licence_number == o.regulatory_licence_number &&\n contact_person_email == o.contact_person_email &&\n trading_country == o.trading_country &&\n trading_address == o.trading_address &&\n trading_name == o.trading_name &&\n number_monthly_transactions == o.number_monthly_transactions &&\n amount_monthly_transactions == o.amount_monthly_transactions &&\n documents == o.documents &&\n metadata == o.metadata &&\n errors == o.errors &&\n onboarding_status == o.onboarding_status &&\n politically_exposed_people == o.politically_exposed_people &&\n external_id == o.external_id &&\n city_of_birth == o.city_of_birth &&\n country_of_birth == o.country_of_birth &&\n gender == o.gender &&\n sales_lead_id == o.sales_lead_id &&\n created_at == o.created_at &&\n company_office_number == o.company_office_number &&\n company_office_number_country == o.company_office_number_country &&\n aml_officer_email == o.aml_officer_email &&\n aml_officer_phone == o.aml_officer_phone &&\n aml_officer_phone_country == o.aml_officer_phone_country &&\n company_website_url == o.company_website_url &&\n number_of_employees_in_company == o.number_of_employees_in_company &&\n list_of_countries_of_operation == o.list_of_countries_of_operation &&\n estimated_annual_revenue_turnover == o.estimated_annual_revenue_turnover &&\n declaration == o.declaration\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n auth_mode == o.auth_mode &&\n count_per_project == o.count_per_project &&\n email_from == o.email_from &&\n email_host == o.email_host &&\n email_port == o.email_port &&\n email_identity == o.email_identity &&\n email_username == o.email_username &&\n email_ssl == o.email_ssl &&\n email_insecure == o.email_insecure &&\n ldap_url == o.ldap_url &&\n ldap_base_dn == o.ldap_base_dn &&\n ldap_filter == o.ldap_filter &&\n ldap_scope == o.ldap_scope &&\n ldap_uid == o.ldap_uid &&\n ldap_search_dn == o.ldap_search_dn &&\n ldap_timeout == o.ldap_timeout &&\n ldap_group_attribute_name == o.ldap_group_attribute_name &&\n ldap_group_base_dn == o.ldap_group_base_dn &&\n ldap_group_search_filter == o.ldap_group_search_filter &&\n ldap_group_search_scope == o.ldap_group_search_scope &&\n ldap_group_admin_dn == o.ldap_group_admin_dn &&\n oidc_client_id == o.oidc_client_id &&\n oidc_endpoint == o.oidc_endpoint &&\n oidc_name == o.oidc_name &&\n oidc_scope == o.oidc_scope &&\n oidc_verify_cert == o.oidc_verify_cert &&\n project_creation_restriction == o.project_creation_restriction &&\n quota_per_project_enable == o.quota_per_project_enable &&\n read_only == o.read_only &&\n self_registration == o.self_registration &&\n storage_per_project == o.storage_per_project &&\n token_expiration == o.token_expiration &&\n verify_remote_cert == o.verify_remote_cert &&\n scan_all_policy == o.scan_all_policy\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n system_id == o.system_id &&\n policy == o.policy &&\n registration_type == o.registration_type &&\n name == o.name &&\n acronym == o.acronym &&\n system_owner == o.system_owner &&\n organization_name == o.organization_name &&\n version_release_no == o.version_release_no &&\n system_type == o.system_type &&\n authorization_status == o.authorization_status &&\n authorization_date == o.authorization_date &&\n authorization_termination_date == o.authorization_termination_date &&\n confidentiality == o.confidentiality &&\n integrity == o.integrity &&\n availability == o.availability &&\n ditpr_id == o.ditpr_id &&\n ditpr_don_id == o.ditpr_don_id &&\n mac == o.mac &&\n dod_confidentiality == o.dod_confidentiality &&\n contingency_plan_tested == o.contingency_plan_tested &&\n contingency_plan_test_date == o.contingency_plan_test_date &&\n security_review_date == o.security_review_date &&\n has_open_poam_item == o.has_open_poam_item &&\n has_open_poam_item90to120_past_scheduled_completion_date == o.has_open_poam_item90to120_past_scheduled_completion_date &&\n has_open_poam_item120_plus_past_scheudled_completion_date == o.has_open_poam_item120_plus_past_scheudled_completion_date\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n address_format == o.address_format &&\n address_format_metadata == o.address_format_metadata &&\n allow_region == o.allow_region &&\n calendar_type == o.calendar_type &&\n calendar_type_metadata == o.calendar_type_metadata &&\n culture_name == o.culture_name &&\n culture_name_metadata == o.culture_name_metadata &&\n currency_code == o.currency_code &&\n currency_code_metadata == o.currency_code_metadata &&\n currency_negative_format == o.currency_negative_format &&\n currency_negative_format_metadata == o.currency_negative_format_metadata &&\n currency_positive_format == o.currency_positive_format &&\n currency_positive_format_metadata == o.currency_positive_format_metadata &&\n custom_date_format == o.custom_date_format &&\n custom_sign_date_format == o.custom_sign_date_format &&\n custom_sign_time_format == o.custom_sign_time_format &&\n custom_time_format == o.custom_time_format &&\n date_format == o.date_format &&\n date_format_metadata == o.date_format_metadata &&\n effective_address_format == o.effective_address_format &&\n effective_calendar_type == o.effective_calendar_type &&\n effective_currency_code == o.effective_currency_code &&\n effective_currency_negative_format == o.effective_currency_negative_format &&\n effective_currency_positive_format == o.effective_currency_positive_format &&\n effective_custom_date_format == o.effective_custom_date_format &&\n effective_custom_time_format == o.effective_custom_time_format &&\n effective_date_format == o.effective_date_format &&\n effective_initial_format == o.effective_initial_format &&\n effective_name_format == o.effective_name_format &&\n effective_time_format == o.effective_time_format &&\n effective_time_zone == o.effective_time_zone &&\n initial_format == o.initial_format &&\n initial_format_metadata == o.initial_format_metadata &&\n name_format == o.name_format &&\n name_format_metadata == o.name_format_metadata &&\n sign_date_format == o.sign_date_format &&\n sign_date_format_metadata == o.sign_date_format_metadata &&\n sign_time_format == o.sign_time_format &&\n sign_time_format_metadata == o.sign_time_format_metadata &&\n time_format == o.time_format &&\n time_format_metadata == o.time_format_metadata &&\n time_zone == o.time_zone &&\n time_zone_metadata == o.time_zone_metadata\n end",
"def test_usage_with_object\n User.owner= @mike\n assert_equal @mike, User.owner\n end",
"def authorized_by(user)\n user.id == self.id\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n management_it_solution_type == o.management_it_solution_type &&\n management_solution_name == o.management_solution_name &&\n management_server_url == o.management_server_url &&\n webservice_override_url == o.webservice_override_url &&\n portal_override_login_url == o.portal_override_login_url &&\n global_login_flag == o.global_login_flag &&\n global_login_username == o.global_login_username &&\n global_login_password == o.global_login_password &&\n using_ssl_flag == o.using_ssl_flag &&\n n_able_username == o.n_able_username &&\n n_able_password == o.n_able_password &&\n override_web_service_location_flag == o.override_web_service_location_flag &&\n override_login_location_flag == o.override_login_location_flag &&\n continuum_api_username == o.continuum_api_username &&\n continuum_api_password == o.continuum_api_password &&\n level_api_username == o.level_api_username &&\n level_api_password == o.level_api_password &&\n level_var_domain == o.level_var_domain &&\n no_display_flag == o.no_display_flag &&\n _info == o._info\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n returned_balances == o.returned_balances &&\n tags == o.tags &&\n transaction_type == o.transaction_type &&\n token == o.token &&\n ref_transaction == o.ref_transaction &&\n node == o.node &&\n network == o.network &&\n sub_network == o.sub_network &&\n mid == o.mid &&\n tid == o.tid &&\n stan == o.stan &&\n ca_name == o.ca_name &&\n ca_street == o.ca_street &&\n ca_zip == o.ca_zip &&\n ca_city == o.ca_city &&\n ca_region == o.ca_region &&\n ca_country == o.ca_country &&\n function_code == o.function_code &&\n reason_code == o.reason_code &&\n response_code == o.response_code &&\n approval_number == o.approval_number &&\n display_message == o.display_message &&\n date == o.date &&\n transmission_date == o.transmission_date &&\n local_transaction_date == o.local_transaction_date &&\n capture_date == o.capture_date &&\n settlement_date == o.settlement_date &&\n itc == o.itc &&\n irc == o.irc &&\n currency_code == o.currency_code &&\n amount == o.amount &&\n additional_amount == o.additional_amount &&\n acquirer_fee == o.acquirer_fee &&\n issuer_fee == o.issuer_fee &&\n rc == o.rc &&\n extrc == o.extrc &&\n duration == o.duration &&\n cardholder == o.cardholder &&\n acting_cardholder == o.acting_cardholder &&\n card == o.card &&\n account == o.account &&\n account2 == o.account2 &&\n mcc == o.mcc &&\n network_reference_id == o.network_reference_id &&\n acquirer_reference_id == o.acquirer_reference_id &&\n retrieval_reference_number == o.retrieval_reference_number &&\n forwarding_inst_id == o.forwarding_inst_id &&\n network_mid == o.network_mid &&\n request_amount == o.request_amount &&\n transaction_state == o.transaction_state &&\n remote_host == o.remote_host &&\n response_amount == o.response_amount &&\n expiration_time == o.expiration_time &&\n incoming_network_request_itc == o.incoming_network_request_itc &&\n digital_wallet_token == o.digital_wallet_token &&\n tranlog_attributes == o.tranlog_attributes &&\n payload == o.payload &&\n layer == o.layer &&\n transaction_name == o.transaction_name &&\n originator == o.originator &&\n acquirer == o.acquirer &&\n gpaorder == o.gpaorder &&\n gateway_log == o.gateway_log\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n summary == o.summary &&\n record_type == o.record_type &&\n board == o.board &&\n status == o.status &&\n project == o.project &&\n phase == o.phase &&\n wbs_code == o.wbs_code &&\n company == o.company &&\n site == o.site &&\n site_name == o.site_name &&\n address_line1 == o.address_line1 &&\n address_line2 == o.address_line2 &&\n city == o.city &&\n state_identifier == o.state_identifier &&\n zip == o.zip &&\n country == o.country &&\n contact == o.contact &&\n contact_phone_number == o.contact_phone_number &&\n contact_phone_extension == o.contact_phone_extension &&\n contact_email_address == o.contact_email_address &&\n type == o.type &&\n sub_type == o.sub_type &&\n item == o.item &&\n team == o.team &&\n owner == o.owner &&\n priority == o.priority &&\n service_location == o.service_location &&\n source == o.source &&\n required_date == o.required_date &&\n budget_hours == o.budget_hours &&\n opportunity == o.opportunity &&\n agreement == o.agreement &&\n severity == o.severity &&\n impact == o.impact &&\n external_x_ref == o.external_x_ref &&\n po_number == o.po_number &&\n knowledge_base_category_id == o.knowledge_base_category_id &&\n knowledge_base_sub_category_id == o.knowledge_base_sub_category_id &&\n allow_all_clients_portal_view == o.allow_all_clients_portal_view &&\n customer_updated_flag == o.customer_updated_flag &&\n automatic_email_contact_flag == o.automatic_email_contact_flag &&\n automatic_email_resource_flag == o.automatic_email_resource_flag &&\n automatic_email_cc_flag == o.automatic_email_cc_flag &&\n automatic_email_cc == o.automatic_email_cc &&\n initial_description == o.initial_description &&\n initial_internal_analysis == o.initial_internal_analysis &&\n initial_resolution == o.initial_resolution &&\n contact_email_lookup == o.contact_email_lookup &&\n process_notifications == o.process_notifications &&\n skip_callback == o.skip_callback &&\n closed_date == o.closed_date &&\n closed_by == o.closed_by &&\n closed_flag == o.closed_flag &&\n date_entered == o.date_entered &&\n entered_by == o.entered_by &&\n actual_hours == o.actual_hours &&\n approved == o.approved &&\n sub_billing_method == o.sub_billing_method &&\n sub_billing_amount == o.sub_billing_amount &&\n sub_date_accepted == o.sub_date_accepted &&\n date_resolved == o.date_resolved &&\n date_resplan == o.date_resplan &&\n date_responded == o.date_responded &&\n resolve_minutes == o.resolve_minutes &&\n res_plan_minutes == o.res_plan_minutes &&\n respond_minutes == o.respond_minutes &&\n is_in_sla == o.is_in_sla &&\n knowledge_base_link_id == o.knowledge_base_link_id &&\n resources == o.resources &&\n parent_ticket_id == o.parent_ticket_id &&\n has_child_ticket == o.has_child_ticket &&\n knowledge_base_link_type == o.knowledge_base_link_type &&\n bill_time == o.bill_time &&\n bill_expenses == o.bill_expenses &&\n bill_products == o.bill_products &&\n predecessor_type == o.predecessor_type &&\n predecessor_id == o.predecessor_id &&\n predecessor_closed_flag == o.predecessor_closed_flag &&\n lag_days == o.lag_days &&\n lag_nonworking_days_flag == o.lag_nonworking_days_flag &&\n estimated_start_date == o.estimated_start_date &&\n duration == o.duration &&\n location_id == o.location_id &&\n business_unit_id == o.business_unit_id &&\n mobile_guid == o.mobile_guid &&\n sla == o.sla &&\n _info == o._info &&\n custom_fields == o.custom_fields\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n access_token_url == o.access_token_url &&\n audience == o.audience &&\n client_id == o.client_id &&\n client_secret == o.client_secret &&\n resource == o.resource &&\n scope == o.scope &&\n token_api_authentication == o.token_api_authentication &&\n type == o.type\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n client_id == o.client_id &&\n secret == o.secret &&\n company_name == o.company_name &&\n is_diligence_attested == o.is_diligence_attested &&\n products == o.products &&\n create_link_customization == o.create_link_customization &&\n logo == o.logo &&\n legal_entity_name == o.legal_entity_name &&\n website == o.website &&\n application_name == o.application_name &&\n technical_contact == o.technical_contact &&\n billing_contact == o.billing_contact &&\n customer_support_info == o.customer_support_info &&\n address == o.address &&\n is_bank_addendum_completed == o.is_bank_addendum_completed &&\n assets_under_management == o.assets_under_management &&\n redirect_uris == o.redirect_uris\n end",
"def organizations_in_vercinity\n\n\tend",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n attachments == o.attachments &&\n created_by_id == o.created_by_id &&\n created_by_name == o.created_by_name &&\n created_on == o.created_on &&\n id == o.id &&\n modified_by_id == o.modified_by_id &&\n modified_by_name == o.modified_by_name &&\n modified_on == o.modified_on &&\n name == o.name &&\n owners == o.owners &&\n status_id == o.status_id &&\n status_name == o.status_name &&\n address_business_city == o.address_business_city &&\n address_business_country == o.address_business_country &&\n address_business_is_primary == o.address_business_is_primary &&\n address_business_line1 == o.address_business_line1 &&\n address_business_state == o.address_business_state &&\n address_business_zip_code == o.address_business_zip_code &&\n address_home_city == o.address_home_city &&\n address_home_country == o.address_home_country &&\n address_home_is_primary == o.address_home_is_primary &&\n address_home_line1 == o.address_home_line1 &&\n address_home_state == o.address_home_state &&\n address_home_zip_code == o.address_home_zip_code &&\n address_other_city == o.address_other_city &&\n address_other_country == o.address_other_country &&\n address_other_is_primary == o.address_other_is_primary &&\n address_other_line1 == o.address_other_line1 &&\n address_other_state == o.address_other_state &&\n address_other_zip_code == o.address_other_zip_code &&\n current_position_company_id == o.current_position_company_id &&\n current_position_company_name == o.current_position_company_name &&\n current_position_title == o.current_position_title &&\n current_position_when_end == o.current_position_when_end &&\n current_position_when_start == o.current_position_when_start &&\n description == o.description &&\n education_accreditation_id == o.education_accreditation_id &&\n education_accreditation_name == o.education_accreditation_name &&\n education_honors == o.education_honors &&\n education_institution_id == o.education_institution_id &&\n education_institution_name == o.education_institution_name &&\n education_when_end == o.education_when_end &&\n education_when_start == o.education_when_start &&\n email_address_other == o.email_address_other &&\n email_address_other_is_primary == o.email_address_other_is_primary &&\n email_address_personal == o.email_address_personal &&\n email_address_personal_is_primary == o.email_address_personal_is_primary &&\n email_address_work == o.email_address_work &&\n email_address_work_is_primary == o.email_address_work_is_primary &&\n ethnicity_id == o.ethnicity_id &&\n ethnicity_name == o.ethnicity_name &&\n external_primary_key == o.external_primary_key &&\n first_name == o.first_name &&\n gender_id == o.gender_id &&\n gender_name == o.gender_name &&\n key_date_anniversary == o.key_date_anniversary &&\n key_date_birthday == o.key_date_birthday &&\n key_date_other == o.key_date_other &&\n last_name == o.last_name &&\n middle_name == o.middle_name &&\n nick_name == o.nick_name &&\n phone_number_fax == o.phone_number_fax &&\n phone_number_fax_extension == o.phone_number_fax_extension &&\n phone_number_fax_is_primary == o.phone_number_fax_is_primary &&\n phone_number_home == o.phone_number_home &&\n phone_number_home_extension == o.phone_number_home_extension &&\n phone_number_home_is_primary == o.phone_number_home_is_primary &&\n phone_number_mobile == o.phone_number_mobile &&\n phone_number_mobile_extension == o.phone_number_mobile_extension &&\n phone_number_mobile_is_primary == o.phone_number_mobile_is_primary &&\n phone_number_other == o.phone_number_other &&\n phone_number_other_extension == o.phone_number_other_extension &&\n phone_number_other_is_primary == o.phone_number_other_is_primary &&\n phone_number_skype == o.phone_number_skype &&\n phone_number_skype_extension == o.phone_number_skype_extension &&\n phone_number_skype_is_primary == o.phone_number_skype_is_primary &&\n phone_number_work_direct == o.phone_number_work_direct &&\n phone_number_work_direct_extension == o.phone_number_work_direct_extension &&\n phone_number_work_direct_is_primary == o.phone_number_work_direct_is_primary &&\n phone_number_work_main == o.phone_number_work_main &&\n phone_number_work_main_extension == o.phone_number_work_main_extension &&\n phone_number_work_main_is_primary == o.phone_number_work_main_is_primary &&\n preferred_contact_method_type_id == o.preferred_contact_method_type_id &&\n preferred_contact_method_type_name == o.preferred_contact_method_type_name &&\n record_type == o.record_type &&\n related_contact_assistant_first_name == o.related_contact_assistant_first_name &&\n related_contact_assistant_id == o.related_contact_assistant_id &&\n related_contact_assistant_is_primary == o.related_contact_assistant_is_primary &&\n related_contact_assistant_last_name == o.related_contact_assistant_last_name &&\n related_contact_client_first_name == o.related_contact_client_first_name &&\n related_contact_client_id == o.related_contact_client_id &&\n related_contact_client_is_primary == o.related_contact_client_is_primary &&\n related_contact_client_last_name == o.related_contact_client_last_name &&\n related_contact_other_first_name == o.related_contact_other_first_name &&\n related_contact_other_id == o.related_contact_other_id &&\n related_contact_other_is_primary == o.related_contact_other_is_primary &&\n related_contact_other_last_name == o.related_contact_other_last_name &&\n related_contact_referred_by_first_name == o.related_contact_referred_by_first_name &&\n related_contact_referred_by_id == o.related_contact_referred_by_id &&\n related_contact_referred_by_is_primary == o.related_contact_referred_by_is_primary &&\n related_contact_referred_by_last_name == o.related_contact_referred_by_last_name &&\n related_contact_spouse_first_name == o.related_contact_spouse_first_name &&\n related_contact_spouse_id == o.related_contact_spouse_id &&\n related_contact_spouse_is_primary == o.related_contact_spouse_is_primary &&\n related_contact_spouse_last_name == o.related_contact_spouse_last_name &&\n salary == o.salary &&\n salary_details == o.salary_details &&\n salutation_id == o.salutation_id &&\n salutation_name == o.salutation_name &&\n social_aim == o.social_aim &&\n social_aim_is_primary == o.social_aim_is_primary &&\n social_facebook_chat == o.social_facebook_chat &&\n social_facebook_chat_is_primary == o.social_facebook_chat_is_primary &&\n social_face_time == o.social_face_time &&\n social_face_time_is_primary == o.social_face_time_is_primary &&\n social_google_talk == o.social_google_talk &&\n social_google_talk_is_primary == o.social_google_talk_is_primary &&\n social_icq == o.social_icq &&\n social_icq_is_primary == o.social_icq_is_primary &&\n social_other == o.social_other &&\n social_other_is_primary == o.social_other_is_primary &&\n social_skype == o.social_skype &&\n social_skype_is_primary == o.social_skype_is_primary &&\n social_twitter == o.social_twitter &&\n social_twitter_is_primary == o.social_twitter_is_primary &&\n social_yahoo_msg == o.social_yahoo_msg &&\n social_yahoo_msg_is_primary == o.social_yahoo_msg_is_primary &&\n source_id == o.source_id &&\n source_name == o.source_name &&\n suffix_id == o.suffix_id &&\n suffix_name == o.suffix_name &&\n tags == o.tags &&\n website_blog == o.website_blog &&\n website_blog_is_primary == o.website_blog_is_primary &&\n website_business == o.website_business &&\n website_business_is_primary == o.website_business_is_primary &&\n website_facebook == o.website_facebook &&\n website_facebook_is_primary == o.website_facebook_is_primary &&\n website_linked_in == o.website_linked_in &&\n website_linked_in_is_primary == o.website_linked_in_is_primary &&\n website_other == o.website_other &&\n website_other_is_primary == o.website_other_is_primary &&\n website_personal == o.website_personal &&\n website_personal_is_primary == o.website_personal_is_primary\n end",
"def test_active_record_gives_different_objects_when_going_back_and_forth\n project = Project.create()\n Actor.create(:project_id => project.id)\n\n actor = Actor.find(1)\n project = actor.project\n old_actor = project.actors.detect {|a| a.id == actor.id }\n assert_not_same actor, old_actor\n assert_equal actor.id, old_actor.id\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n rfc == o.rfc &&\n legal_name == o.legal_name &&\n commercial_name == o.commercial_name &&\n credit_days == o.credit_days &&\n credit_amount == o.credit_amount &&\n payment_method == o.payment_method &&\n creation_date == o.creation_date &&\n status == o.status &&\n sales_contact == o.sales_contact &&\n credit_contact == o.credit_contact &&\n loctaion == o.loctaion &&\n comments == o.comments &&\n price_list == o.price_list &&\n payment_term_type == o.payment_term_type &&\n email == o.email &&\n telephones == o.telephones &&\n number == o.number &&\n account_number == o.account_number &&\n default_discount == o.default_discount &&\n client_source == o.client_source &&\n account == o.account &&\n addresses == o.addresses\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n url == o.url &&\n external_id == o.external_id &&\n first_name == o.first_name &&\n last_name == o.last_name &&\n middle_name == o.middle_name &&\n birth_date == o.birth_date &&\n gender == o.gender &&\n language == o.language &&\n phone == o.phone &&\n allow_phone_contact == o.allow_phone_contact &&\n email == o.email &&\n allow_email_contact == o.allow_email_contact &&\n notes == o.notes &&\n date_created == o.date_created &&\n date_modified == o.date_modified &&\n ext_date_created == o.ext_date_created &&\n ext_date_modified == o.ext_date_modified &&\n doc_type == o.doc_type &&\n doc_issuer_info == o.doc_issuer_info &&\n doc_series == o.doc_series &&\n doc_number == o.doc_number &&\n department_code == o.department_code &&\n department_name == o.department_name &&\n doc_issue_date == o.doc_issue_date &&\n doc_expiration_date == o.doc_expiration_date &&\n is_closed == o.is_closed &&\n merged_to == o.merged_to &&\n building_no == o.building_no &&\n city == o.city &&\n country_code == o.country_code &&\n country_name == o.country_name &&\n district == o.district &&\n flat_no == o.flat_no &&\n house_no == o.house_no &&\n region == o.region &&\n room_no == o.room_no &&\n settlement_type == o.settlement_type &&\n street == o.street &&\n raw_address == o.raw_address &&\n cards == o.cards &&\n view_url == o.view_url &&\n preferences == o.preferences\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n gl_class == o.gl_class &&\n gl_type_id == o.gl_type_id &&\n document_date == o.document_date &&\n document_number == o.document_number &&\n document_type == o.document_type &&\n memo == o.memo &&\n description == o.description &&\n attention == o.attention &&\n sales_territory == o.sales_territory &&\n company == o.company &&\n company_type == o.company_type &&\n company_account_number == o.company_account_number &&\n site == o.site &&\n billing_terms == o.billing_terms &&\n billing_terms_xref == o.billing_terms_xref &&\n due_days == o.due_days &&\n due_date == o.due_date &&\n email_delivery_flag == o.email_delivery_flag &&\n print_delivery_flag == o.print_delivery_flag &&\n agreement_pre_payment_flag == o.agreement_pre_payment_flag &&\n account_number == o.account_number &&\n billing_type == o.billing_type &&\n gl_entry_ids == o.gl_entry_ids &&\n purchase_order == o.purchase_order &&\n project == o.project &&\n currency == o.currency &&\n total == o.total &&\n sales_rep_id == o.sales_rep_id &&\n sales_rep_name == o.sales_rep_name &&\n taxable == o.taxable &&\n taxable_total == o.taxable_total &&\n tax_code == o.tax_code &&\n tax_group_rate == o.tax_group_rate &&\n piggy_back_flag == o.piggy_back_flag &&\n tax_account_number == o.tax_account_number &&\n sales_tax == o.sales_tax &&\n state_tax == o.state_tax &&\n county_tax == o.county_tax &&\n city_tax == o.city_tax &&\n taxable_amount1 == o.taxable_amount1 &&\n taxable_amount2 == o.taxable_amount2 &&\n taxable_amount3 == o.taxable_amount3 &&\n taxable_amount4 == o.taxable_amount4 &&\n taxable_amount5 == o.taxable_amount5 &&\n tax_agency_xref == o.tax_agency_xref &&\n state_tax_xref == o.state_tax_xref &&\n county_tax_xref == o.county_tax_xref &&\n tax_id == o.tax_id &&\n tax_dp_applied_flag == o.tax_dp_applied_flag &&\n use_avalara_flag == o.use_avalara_flag &&\n send_avalara_tax_flag == o.send_avalara_tax_flag &&\n ship_to_company == o.ship_to_company &&\n ship_company_account_number == o.ship_company_account_number &&\n ship_company_type == o.ship_company_type &&\n ship_tax_id == o.ship_tax_id &&\n ship_site == o.ship_site &&\n ship_contact == o.ship_contact &&\n detail == o.detail\n end",
"def author_identity_different?(attribs)\n !(\n # not the identical identity where Author is assumed to be Stanford University\n # checks in order of likelihood of changes\n # note that this code works for nil/empty string comparisons by calling `to_s`\n first_name.to_s.casecmp(attribs[:first_name].to_s) == 0 &&\n middle_name.to_s.casecmp(attribs[:middle_name].to_s) == 0 &&\n last_name.to_s.casecmp(attribs[:last_name].to_s) == 0 &&\n institution.to_s.casecmp(attribs[:institution].to_s) == 0\n )\n end",
"def authorization_object\n nil\n end",
"def authorization_object\n nil\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account_id_guid == o.account_id_guid &&\n account_name == o.account_name &&\n account_settings == o.account_settings &&\n allow_transaction_rooms == o.allow_transaction_rooms &&\n billing_period_days_remaining == o.billing_period_days_remaining &&\n billing_period_end_date == o.billing_period_end_date &&\n billing_period_envelopes_allowed == o.billing_period_envelopes_allowed &&\n billing_period_envelopes_sent == o.billing_period_envelopes_sent &&\n billing_period_start_date == o.billing_period_start_date &&\n billing_profile == o.billing_profile &&\n can_upgrade == o.can_upgrade &&\n connect_permission == o.connect_permission &&\n created_date == o.created_date &&\n currency_code == o.currency_code &&\n current_plan_id == o.current_plan_id &&\n distributor_code == o.distributor_code &&\n docu_sign_landing_url == o.docu_sign_landing_url &&\n dss_values == o.dss_values &&\n envelope_sending_blocked == o.envelope_sending_blocked &&\n envelope_unit_price == o.envelope_unit_price &&\n external_account_id == o.external_account_id &&\n forgotten_password_questions_count == o.forgotten_password_questions_count &&\n is_downgrade == o.is_downgrade &&\n payment_method == o.payment_method &&\n plan_classification == o.plan_classification &&\n plan_end_date == o.plan_end_date &&\n plan_name == o.plan_name &&\n plan_start_date == o.plan_start_date &&\n recipient_domains == o.recipient_domains &&\n seats_allowed == o.seats_allowed &&\n seats_in_use == o.seats_in_use &&\n status21_cfr_part11 == o.status21_cfr_part11 &&\n suspension_date == o.suspension_date &&\n suspension_status == o.suspension_status\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n cardtransaction_id == o.cardtransaction_id &&\n card_id == o.card_id &&\n wallet_id == o.wallet_id &&\n acquirer_id == o.acquirer_id &&\n wallet_currency == o.wallet_currency &&\n merchant_id == o.merchant_id &&\n merchant_name == o.merchant_name &&\n merchant_city == o.merchant_city &&\n merchant_country == o.merchant_country &&\n mcc_code == o.mcc_code &&\n payment_local_time == o.payment_local_time &&\n public_token == o.public_token &&\n payment_amount == o.payment_amount &&\n payment_currency == o.payment_currency &&\n fees == o.fees &&\n payment_country == o.payment_country &&\n payment_id == o.payment_id &&\n payment_status == o.payment_status &&\n payment_local_amount == o.payment_local_amount &&\n pos_cardholder_presence == o.pos_cardholder_presence &&\n pos_postcode == o.pos_postcode &&\n pos_country == o.pos_country &&\n pos_terminal_id == o.pos_terminal_id &&\n pos_card_presence == o.pos_card_presence &&\n pan_entry_method == o.pan_entry_method &&\n authorization_note == o.authorization_note &&\n authorization_response_code == o.authorization_response_code &&\n authorization_issuer_id == o.authorization_issuer_id &&\n authorization_issuer_time == o.authorization_issuer_time &&\n authorization_mti == o.authorization_mti &&\n authorized_balance == o.authorized_balance &&\n limit_atm_year == o.limit_atm_year &&\n limit_atm_month == o.limit_atm_month &&\n limit_atm_week == o.limit_atm_week &&\n limit_atm_day == o.limit_atm_day &&\n limit_atm_all == o.limit_atm_all &&\n limit_payment_year == o.limit_payment_year &&\n limit_payment_month == o.limit_payment_month &&\n limit_payment_week == o.limit_payment_week &&\n limit_payment_day == o.limit_payment_day &&\n limit_payment_all == o.limit_payment_all &&\n total_limit_atm_year == o.total_limit_atm_year &&\n total_limit_atm_month == o.total_limit_atm_month &&\n total_limit_atm_week == o.total_limit_atm_week &&\n total_limit_atm_day == o.total_limit_atm_day &&\n total_limit_atm_all == o.total_limit_atm_all &&\n total_limit_payment_year == o.total_limit_payment_year &&\n total_limit_payment_month == o.total_limit_payment_month &&\n total_limit_payment_week == o.total_limit_payment_week &&\n total_limit_payment_day == o.total_limit_payment_day &&\n total_limit_payment_all == o.total_limit_payment_all &&\n total_rows == o.total_rows\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n marketplace_technical_code == o.marketplace_technical_code &&\n account_id == o.account_id &&\n beez_up_order_id == o.beez_up_order_id &&\n beez_up_order_url == o.beez_up_order_url &&\n marketplace_business_code == o.marketplace_business_code &&\n order_marketplace_order_id == o.order_marketplace_order_id &&\n order_status_beez_up_order_status == o.order_status_beez_up_order_status &&\n order_status_marketplace_order_status == o.order_status_marketplace_order_status &&\n order_merchant_order_id == o.order_merchant_order_id &&\n order_merchant_e_commerce_software_name == o.order_merchant_e_commerce_software_name &&\n order_merchant_e_commerce_software_version == o.order_merchant_e_commerce_software_version &&\n order_purchase_utc_date == o.order_purchase_utc_date &&\n order_last_modification_utc_date == o.order_last_modification_utc_date &&\n order_marketplace_last_modification_utc_date == o.order_marketplace_last_modification_utc_date &&\n order_buyer_name == o.order_buyer_name &&\n order_total_price == o.order_total_price &&\n order_currency_code == o.order_currency_code &&\n processing == o.processing &&\n etag == o.etag &&\n links == o.links &&\n order_market_place_channel == o.order_market_place_channel &&\n order_total_tax == o.order_total_tax &&\n order_total_commission == o.order_total_commission &&\n order_payment_method == o.order_payment_method &&\n order_paying_utc_date == o.order_paying_utc_date &&\n order_comment == o.order_comment &&\n order_shipping_civility == o.order_shipping_civility &&\n order_shipping_company_name == o.order_shipping_company_name &&\n order_shipping_address_name == o.order_shipping_address_name &&\n order_shipping_email == o.order_shipping_email &&\n order_shipping_address_line1 == o.order_shipping_address_line1 &&\n order_shipping_address_line2 == o.order_shipping_address_line2 &&\n order_shipping_address_line3 == o.order_shipping_address_line3 &&\n order_shipping_address_postal_code == o.order_shipping_address_postal_code &&\n order_shipping_address_city == o.order_shipping_address_city &&\n order_shipping_address_state_or_region == o.order_shipping_address_state_or_region &&\n order_shipping_address_country_name == o.order_shipping_address_country_name &&\n order_shipping_address_country_iso_code_alpha2 == o.order_shipping_address_country_iso_code_alpha2 &&\n order_shipping_phone == o.order_shipping_phone &&\n order_shipping_mobile_phone == o.order_shipping_mobile_phone &&\n order_shipping_price == o.order_shipping_price &&\n order_shipping_method == o.order_shipping_method &&\n order_shipping_shipping_tax == o.order_shipping_shipping_tax &&\n order_shipping_earliest_ship_utc_date == o.order_shipping_earliest_ship_utc_date &&\n order_shipping_latest_ship_utc_date == o.order_shipping_latest_ship_utc_date &&\n order_buyer_identifier == o.order_buyer_identifier &&\n order_buyer_civility == o.order_buyer_civility &&\n order_buyer_company_name == o.order_buyer_company_name &&\n order_buyer_email == o.order_buyer_email &&\n order_buyer_address_line1 == o.order_buyer_address_line1 &&\n order_buyer_address_line2 == o.order_buyer_address_line2 &&\n order_buyer_address_line3 == o.order_buyer_address_line3 &&\n order_buyer_address_postal_code == o.order_buyer_address_postal_code &&\n order_buyer_address_city == o.order_buyer_address_city &&\n order_buyer_address_state_or_region == o.order_buyer_address_state_or_region &&\n order_buyer_address_country_name == o.order_buyer_address_country_name &&\n order_buyer_address_country_iso_code_alpha2 == o.order_buyer_address_country_iso_code_alpha2 &&\n order_buyer_phone == o.order_buyer_phone &&\n order_buyer_mobile_phone == o.order_buyer_mobile_phone &&\n order_order_source_uri == o.order_order_source_uri &&\n order_order_items_source_uri == o.order_order_items_source_uri &&\n order_items == o.order_items &&\n transition_links == o.transition_links\n end",
"def authorized_by(authorizer)\n authorizer.to_s.camelize.constantize # get authorizer loaded\n alias_method :old_users, :users\n alias_method :old_method_missing, :method_missing\n include TransitiveAuthorization::Authorizee::InstanceMethods\n self.cattr_accessor :transitive_authorizer\n self.transitive_authorizer = authorizer\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n remit_name == o.remit_name &&\n location == o.location &&\n address_one == o.address_one &&\n address_two == o.address_two &&\n city == o.city &&\n state == o.state &&\n zip == o.zip &&\n country == o.country &&\n phone == o.phone &&\n invoice_title == o.invoice_title &&\n payable_name == o.payable_name &&\n topcomment == o.topcomment &&\n invoice_footer == o.invoice_footer &&\n quote_footer == o.quote_footer &&\n overall_invoice_default == o.overall_invoice_default &&\n standard_invoice_actual == o.standard_invoice_actual &&\n standard_invoice_fixed == o.standard_invoice_fixed &&\n progress_invoice == o.progress_invoice &&\n agreement_invoice == o.agreement_invoice &&\n credit_memo_invoice == o.credit_memo_invoice &&\n down_payment_invoice == o.down_payment_invoice &&\n misc_invoice == o.misc_invoice &&\n sales_order_invoice == o.sales_order_invoice &&\n exclude_do_not_bill_time_flag == o.exclude_do_not_bill_time_flag &&\n exclude_do_not_bill_expense_flag == o.exclude_do_not_bill_expense_flag &&\n exclude_do_not_bill_product_flag == o.exclude_do_not_bill_product_flag &&\n prefix_suffix_flag == o.prefix_suffix_flag &&\n prefix_suffix_text == o.prefix_suffix_text &&\n charge_adj_to_firm_flag == o.charge_adj_to_firm_flag &&\n no_watermark_flag == o.no_watermark_flag &&\n display_tax_flag == o.display_tax_flag &&\n allow_restricted_dept_on_routing_flag == o.allow_restricted_dept_on_routing_flag &&\n bill_ticket_separately_flag == o.bill_ticket_separately_flag &&\n bill_ticket_complete_flag == o.bill_ticket_complete_flag &&\n bill_ticket_unapproved_flag == o.bill_ticket_unapproved_flag &&\n bill_project_complete_flag == o.bill_project_complete_flag &&\n bill_project_unapproved_flag == o.bill_project_unapproved_flag &&\n progress_time_flag == o.progress_time_flag &&\n restrict_project_downpayment_flag == o.restrict_project_downpayment_flag &&\n bill_sales_order_complete_flag == o.bill_sales_order_complete_flag &&\n bill_product_after_ship_flag == o.bill_product_after_ship_flag &&\n restrict_downpayment_flag == o.restrict_downpayment_flag &&\n copy_non_service_products_flag == o.copy_non_service_products_flag &&\n copy_service_products_flag == o.copy_service_products_flag &&\n copy_agreement_products_flag == o.copy_agreement_products_flag &&\n print_logo_flag == o.print_logo_flag &&\n read_receipt_flag == o.read_receipt_flag &&\n delivery_receipt_flag == o.delivery_receipt_flag &&\n disable_routing_email_flag == o.disable_routing_email_flag &&\n email_template == o.email_template &&\n localized_country == o.localized_country &&\n business_number == o.business_number &&\n currency == o.currency &&\n custom_label == o.custom_label &&\n custom_text == o.custom_text &&\n company_code == o.company_code &&\n exclude_avalara_flag == o.exclude_avalara_flag &&\n _info == o._info\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n policy_description == o.policy_description &&\n team_id == o.team_id &&\n filter == o.filter &&\n time_restrictions == o.time_restrictions &&\n enabled == o.enabled &&\n type == o.type &&\n ignore_original_actions == o.ignore_original_actions &&\n ignore_original_details == o.ignore_original_details &&\n ignore_original_responders == o.ignore_original_responders &&\n ignore_original_tags == o.ignore_original_tags &&\n ignore_original_teams == o.ignore_original_teams &&\n continue == o.continue &&\n _alias == o._alias &&\n description == o.description &&\n entity == o.entity &&\n message == o.message &&\n source == o.source &&\n actions == o.actions &&\n responders == o.responders &&\n tags == o.tags &&\n details == o.details &&\n priority == o.priority\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n admin_flag == o.admin_flag &&\n allow_expenses_entered_against_companies_flag == o.allow_expenses_entered_against_companies_flag &&\n allow_in_cell_entry_on_time_sheet == o.allow_in_cell_entry_on_time_sheet &&\n billable_forecast == o.billable_forecast &&\n calendar == o.calendar &&\n calendar_sync_integration_flag == o.calendar_sync_integration_flag &&\n country == o.country &&\n daily_capacity == o.daily_capacity &&\n days_tolerance == o.days_tolerance &&\n default_department_id == o.default_department_id &&\n default_email == o.default_email &&\n default_location_id == o.default_location_id &&\n default_phone == o.default_phone &&\n disable_online_flag == o.disable_online_flag &&\n enable_ldap_authentication_flag == o.enable_ldap_authentication_flag &&\n enable_mobile_flag == o.enable_mobile_flag &&\n enable_mobile_gps_flag == o.enable_mobile_gps_flag &&\n enter_time_against_company_flag == o.enter_time_against_company_flag &&\n expense_approver == o.expense_approver &&\n first_name == o.first_name &&\n hide_member_in_dispatch_portal_flag == o.hide_member_in_dispatch_portal_flag &&\n hire_date == o.hire_date &&\n home_email == o.home_email &&\n home_extension == o.home_extension &&\n home_phone == o.home_phone &&\n hourly_cost == o.hourly_cost &&\n hourly_rate == o.hourly_rate &&\n id == o.id &&\n identifier == o.identifier &&\n inactive_date == o.inactive_date &&\n inactive_flag == o.inactive_flag &&\n include_in_utilization_reporting_flag == o.include_in_utilization_reporting_flag &&\n last_login == o.last_login &&\n last_name == o.last_name &&\n license_class == o.license_class &&\n mapi_name == o.mapi_name &&\n middle_initial == o.middle_initial &&\n minimum_hours == o.minimum_hours &&\n mobile_email == o.mobile_email &&\n mobile_extension == o.mobile_extension &&\n mobile_phone == o.mobile_phone &&\n notes == o.notes &&\n office_email == o.office_email &&\n office_extension == o.office_extension &&\n office_phone == o.office_phone &&\n project_default_board == o.project_default_board &&\n project_default_department_id == o.project_default_department_id &&\n project_default_location_id == o.project_default_location_id &&\n reports_to == o.reports_to &&\n require_expense_entry_flag == o.require_expense_entry_flag &&\n require_start_and_end_time_on_time_entry_flag == o.require_start_and_end_time_on_time_entry_flag &&\n require_time_sheet_entry_flag == o.require_time_sheet_entry_flag &&\n restrict_default_sales_territory_flag == o.restrict_default_sales_territory_flag &&\n restrict_default_warehouse_bin_flag == o.restrict_default_warehouse_bin_flag &&\n restrict_default_warehouse_flag == o.restrict_default_warehouse_flag &&\n restrict_department_flag == o.restrict_department_flag &&\n restrict_location_flag == o.restrict_location_flag &&\n restrict_project_default_department_flag == o.restrict_project_default_department_flag &&\n restrict_project_default_location_flag == o.restrict_project_default_location_flag &&\n restrict_schedule_flag == o.restrict_schedule_flag &&\n restrict_service_default_department_flag == o.restrict_service_default_department_flag &&\n restrict_service_default_location_flag == o.restrict_service_default_location_flag &&\n sales_default_location_id == o.sales_default_location_id &&\n schedule_capacity == o.schedule_capacity &&\n schedule_default_department_id == o.schedule_default_department_id &&\n schedule_default_location_id == o.schedule_default_location_id &&\n security_level == o.security_level &&\n security_location_id == o.security_location_id &&\n security_role == o.security_role &&\n service_default_board == o.service_default_board &&\n service_default_department_id == o.service_default_department_id &&\n service_default_location_id == o.service_default_location_id &&\n service_location == o.service_location &&\n service_teams == o.service_teams &&\n time_approver == o.time_approver &&\n time_reminder_email_flag == o.time_reminder_email_flag &&\n time_sheet_start_date == o.time_sheet_start_date &&\n time_zone == o.time_zone &&\n title == o.title &&\n type == o.type &&\n vendor_number == o.vendor_number &&\n warehouse == o.warehouse &&\n warehouse_bin == o.warehouse_bin &&\n work_role == o.work_role &&\n work_type == o.work_type &&\n _info == o._info &&\n system_flag == o.system_flag\n end",
"def test_when_following_belongs_to_and_back_different_objects_are_given\n project = Project.create()\n Actor.create(:project_id => project.id)\n\n actor = Actor.find_version(1, 2)\n project = actor.project\n old_actor = project.actors.detect {|a| a.id == actor.id }\n assert_not_same actor, old_actor\n assert_equal actor.id, old_actor.id\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n type == o.type &&\n name == o.name &&\n is_active == o.is_active &&\n external_url == o.external_url &&\n external_authorization_type == o.external_authorization_type &&\n external_user_name == o.external_user_name &&\n external_password == o.external_password &&\n external_bearer_token == o.external_bearer_token &&\n external_headers == o.external_headers\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n _self == o._self &&\n _links == o._links &&\n _schema == o._schema &&\n _revision == o._revision &&\n _system_owned == o._system_owned &&\n display_name == o.display_name &&\n description == o.description &&\n tags == o.tags &&\n _create_user == o._create_user &&\n _protection == o._protection &&\n _create_time == o._create_time &&\n _last_modified_time == o._last_modified_time &&\n _last_modified_user == o._last_modified_user &&\n id == o.id &&\n resource_type == o.resource_type &&\n ip_protocol == o.ip_protocol &&\n server_tcp_profile_id == o.server_tcp_profile_id &&\n sorry_pool_id == o.sorry_pool_id &&\n port == o.port &&\n server_ssl_profile_binding == o.server_ssl_profile_binding &&\n pool_id == o.pool_id &&\n client_tcp_profile_id == o.client_tcp_profile_id &&\n default_pool_member_port == o.default_pool_member_port &&\n access_log_enabled == o.access_log_enabled &&\n application_profile_id == o.application_profile_id &&\n max_concurrent_connections == o.max_concurrent_connections &&\n rule_ids == o.rule_ids &&\n max_new_connection_rate == o.max_new_connection_rate &&\n persistence_profile_id == o.persistence_profile_id &&\n client_ssl_profile_binding == o.client_ssl_profile_binding &&\n default_pool_member_ports == o.default_pool_member_ports &&\n ip_address == o.ip_address &&\n ports == o.ports &&\n enabled == o.enabled\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n accounting_code == o.accounting_code &&\n activation_codes == o.activation_codes &&\n arbitrary_unit_cost == o.arbitrary_unit_cost &&\n auto_order_last_rebill_dts == o.auto_order_last_rebill_dts &&\n auto_order_schedule == o.auto_order_schedule &&\n barcode == o.barcode &&\n channel_partner_item_id == o.channel_partner_item_id &&\n cogs == o.cogs &&\n component_unit_value == o.component_unit_value &&\n cost == o.cost &&\n country_code_of_origin == o.country_code_of_origin &&\n customs_description == o.customs_description &&\n description == o.description &&\n discount == o.discount &&\n discount_quantity == o.discount_quantity &&\n discount_shipping_weight == o.discount_shipping_weight &&\n distribution_center_code == o.distribution_center_code &&\n edi == o.edi &&\n exclude_coupon == o.exclude_coupon &&\n free_shipping == o.free_shipping &&\n hazmat == o.hazmat &&\n height == o.height &&\n item_index == o.item_index &&\n item_reference_oid == o.item_reference_oid &&\n kit == o.kit &&\n kit_component == o.kit_component &&\n length == o.length &&\n manufacturer_sku == o.manufacturer_sku &&\n max_days_time_in_transit == o.max_days_time_in_transit &&\n merchant_item_id == o.merchant_item_id &&\n mix_and_match_group_name == o.mix_and_match_group_name &&\n mix_and_match_group_oid == o.mix_and_match_group_oid &&\n no_shipping_discount == o.no_shipping_discount &&\n options == o.options &&\n packed_by_user == o.packed_by_user &&\n parent_item_index == o.parent_item_index &&\n parent_merchant_item_id == o.parent_merchant_item_id &&\n perishable_class == o.perishable_class &&\n pricing_tier_name == o.pricing_tier_name &&\n properties == o.properties &&\n quantity == o.quantity &&\n quantity_refunded == o.quantity_refunded &&\n quickbooks_class == o.quickbooks_class &&\n refund_reason == o.refund_reason &&\n return_reason == o.return_reason &&\n ship_separately == o.ship_separately &&\n shipped_by_user == o.shipped_by_user &&\n shipped_dts == o.shipped_dts &&\n shipping_status == o.shipping_status &&\n special_product_type == o.special_product_type &&\n tags == o.tags &&\n tax_free == o.tax_free &&\n tax_product_type == o.tax_product_type &&\n taxable_cost == o.taxable_cost &&\n total_cost_with_discount == o.total_cost_with_discount &&\n total_refunded == o.total_refunded &&\n transmitted_to_distribution_center_dts == o.transmitted_to_distribution_center_dts &&\n unit_cost_with_discount == o.unit_cost_with_discount &&\n upsell == o.upsell &&\n weight == o.weight &&\n width == o.width\n end",
"def test_orders_auth \n c = customers(:bob)\n assert_equal(orders(:bob_order), c.find_order(1))\n assert_nil(c.find_order(2))\n assert_nil(c.find_order(100000))\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n type == o.type &&\n source == o.source &&\n reason == o.reason &&\n queue == o.queue &&\n state == o.state &&\n customer == o.customer &&\n contact == o.contact &&\n description == o.description &&\n email == o.email &&\n email2 == o.email2 &&\n watchers == o.watchers &&\n comments == o.comments &&\n last_comment == o.last_comment &&\n ticket_number == o.ticket_number &&\n performer == o.performer &&\n solution_date == o.solution_date &&\n solution_user == o.solution_user &&\n rating == o.rating &&\n rating_author == o.rating_author &&\n rating_date == o.rating_date &&\n rating_source == o.rating_source &&\n rating_comment == o.rating_comment &&\n partner == o.partner &&\n parent_ticket == o.parent_ticket &&\n dispute == o.dispute &&\n time_decision == o.time_decision &&\n incident_type_direction_id == o.incident_type_direction_id &&\n license_id == o.license_id &&\n is_approved == o.is_approved &&\n main_product_id == o.main_product_id &&\n jira_service_id == o.jira_service_id &&\n is_gr == o.is_gr &&\n fields == o.fields &&\n created_by == o.created_by &&\n created_on == o.created_on &&\n modified_by == o.modified_by &&\n modified_on == o.modified_on &&\n id == o.id &&\n name == o.name &&\n state_code == o.state_code &&\n status_code == o.status_code\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n first_name == o.first_name &&\n last_name == o.last_name &&\n type == o.type &&\n company == o.company &&\n site == o.site &&\n address_line1 == o.address_line1 &&\n address_line2 == o.address_line2 &&\n city == o.city &&\n state == o.state &&\n zip == o.zip &&\n country == o.country &&\n relationship == o.relationship &&\n department == o.department &&\n inactive_flag == o.inactive_flag &&\n default_merge_contact_id == o.default_merge_contact_id &&\n security_identifier == o.security_identifier &&\n manager_contact_id == o.manager_contact_id &&\n assistant_contact_id == o.assistant_contact_id &&\n title == o.title &&\n school == o.school &&\n nick_name == o.nick_name &&\n married_flag == o.married_flag &&\n children_flag == o.children_flag &&\n significant_other == o.significant_other &&\n portal_password == o.portal_password &&\n portal_security_level == o.portal_security_level &&\n disable_portal_login_flag == o.disable_portal_login_flag &&\n unsubscribe_flag == o.unsubscribe_flag &&\n gender == o.gender &&\n birth_day == o.birth_day &&\n anniversary == o.anniversary &&\n presence == o.presence &&\n mobile_guid == o.mobile_guid &&\n facebook_url == o.facebook_url &&\n twitter_url == o.twitter_url &&\n linked_in_url == o.linked_in_url &&\n communication_items == o.communication_items &&\n _info == o._info &&\n custom_fields == o.custom_fields\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n user == o.user &&\n client == o.client &&\n remote_ip == o.remote_ip &&\n service_name == o.service_name &&\n event_date == o.event_date &&\n message == o.message &&\n action == o.action &&\n entity == o.entity &&\n entity_type == o.entity_type &&\n property_changes == o.property_changes &&\n context == o.context\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n actual_value == o.actual_value &&\n additional_contact_client_first_name == o.additional_contact_client_first_name &&\n additional_contact_client_id == o.additional_contact_client_id &&\n additional_contact_client_is_primary == o.additional_contact_client_is_primary &&\n additional_contact_client_last_name == o.additional_contact_client_last_name &&\n address_business_city == o.address_business_city &&\n address_business_country == o.address_business_country &&\n address_business_is_primary == o.address_business_is_primary &&\n address_business_line1 == o.address_business_line1 &&\n address_business_state == o.address_business_state &&\n address_business_zip_code == o.address_business_zip_code &&\n address_other_city == o.address_other_city &&\n address_other_country == o.address_other_country &&\n address_other_is_primary == o.address_other_is_primary &&\n address_other_line1 == o.address_other_line1 &&\n address_other_state == o.address_other_state &&\n address_other_zip_code == o.address_other_zip_code &&\n bill_rate == o.bill_rate &&\n bonus == o.bonus &&\n commission == o.commission &&\n company_id == o.company_id &&\n company_name == o.company_name &&\n compensation == o.compensation &&\n compensation_details == o.compensation_details &&\n custom_field1 == o.custom_field1 &&\n custom_field10 == o.custom_field10 &&\n custom_field11 == o.custom_field11 &&\n custom_field12 == o.custom_field12 &&\n custom_field13 == o.custom_field13 &&\n custom_field14 == o.custom_field14 &&\n custom_field15 == o.custom_field15 &&\n custom_field16 == o.custom_field16 &&\n custom_field17 == o.custom_field17 &&\n custom_field18 == o.custom_field18 &&\n custom_field19 == o.custom_field19 &&\n custom_field2 == o.custom_field2 &&\n custom_field20 == o.custom_field20 &&\n custom_field21 == o.custom_field21 &&\n custom_field22 == o.custom_field22 &&\n custom_field23 == o.custom_field23 &&\n custom_field24 == o.custom_field24 &&\n custom_field25 == o.custom_field25 &&\n custom_field26 == o.custom_field26 &&\n custom_field27 == o.custom_field27 &&\n custom_field28 == o.custom_field28 &&\n custom_field29 == o.custom_field29 &&\n custom_field3 == o.custom_field3 &&\n custom_field30 == o.custom_field30 &&\n custom_field4 == o.custom_field4 &&\n custom_field5 == o.custom_field5 &&\n custom_field6 == o.custom_field6 &&\n custom_field7 == o.custom_field7 &&\n custom_field8 == o.custom_field8 &&\n custom_field9 == o.custom_field9 &&\n description == o.description &&\n discount == o.discount &&\n estimated_close_date == o.estimated_close_date &&\n external_primary_key == o.external_primary_key &&\n fee == o.fee &&\n fee_percent == o.fee_percent &&\n hourly_rate == o.hourly_rate &&\n is_lead == o.is_lead &&\n is_on_hold == o.is_on_hold &&\n job_title_id == o.job_title_id &&\n job_title_name == o.job_title_name &&\n job_types == o.job_types &&\n lead_source_id == o.lead_source_id &&\n lead_source_name == o.lead_source_name &&\n margin == o.margin &&\n name == o.name &&\n number_of_openings == o.number_of_openings &&\n opportunity_type_id == o.opportunity_type_id &&\n opportunity_type_name == o.opportunity_type_name &&\n parent_job_id == o.parent_job_id &&\n parent_job_name == o.parent_job_name &&\n pay_rate == o.pay_rate &&\n potential_value == o.potential_value &&\n priority_id == o.priority_id &&\n priority_name == o.priority_name &&\n probability == o.probability &&\n salary == o.salary &&\n start_date == o.start_date &&\n tags == o.tags &&\n total_hours == o.total_hours &&\n website_description == o.website_description &&\n website_description_is_primary == o.website_description_is_primary &&\n website_other == o.website_other &&\n website_other_is_primary == o.website_other_is_primary\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n type == o.type &&\n page_access_token == o.page_access_token &&\n app_id == o.app_id &&\n app_secret == o.app_secret &&\n account_sid == o.account_sid &&\n auth_token == o.auth_token &&\n phone_number_sid == o.phone_number_sid &&\n token == o.token &&\n channel_access_token == o.channel_access_token &&\n encoding_aes_key == o.encoding_aes_key &&\n from_address == o.from_address &&\n certificate == o.certificate &&\n password == o.password &&\n auto_update_badge == o.auto_update_badge &&\n server_key == o.server_key &&\n sender_id == o.sender_id &&\n consumer_key == o.consumer_key &&\n consumer_secret == o.consumer_secret &&\n access_token_key == o.access_token_key &&\n access_token_secret == o.access_token_secret\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n partner_short_id == o.partner_short_id &&\n full_name == o.full_name &&\n type == o.type &&\n payment_scenario == o.payment_scenario &&\n telephone == o.telephone &&\n site_url == o.site_url &&\n distribution_manager == o.distribution_manager &&\n level == o.level &&\n is_external_partner == o.is_external_partner &&\n parent_partner == o.parent_partner &&\n top_partner == o.top_partner &&\n brand_name_for_site == o.brand_name_for_site &&\n web_site_url == o.web_site_url &&\n partner_level_name == o.partner_level_name &&\n legal_address == o.legal_address &&\n tax_number == o.tax_number &&\n main_state_reg_number == o.main_state_reg_number &&\n is_has_telephony == o.is_has_telephony &&\n soft_phone_users == o.soft_phone_users &&\n web_rtc_users == o.web_rtc_users &&\n all_users == o.all_users &&\n server_url == o.server_url &&\n top_partner_size == o.top_partner_size &&\n top_partner_size_name == o.top_partner_size_name &&\n not_suspended_count == o.not_suspended_count &&\n suspended_count == o.suspended_count &&\n manager_count == o.manager_count &&\n root_partner_name == o.root_partner_name &&\n created_by == o.created_by &&\n created_on == o.created_on &&\n modified_by == o.modified_by &&\n modified_on == o.modified_on &&\n id == o.id &&\n name == o.name &&\n state_code == o.state_code &&\n status_code == o.status_code\n end",
"def ==(object)\n return true if object.equal?(self)\n if object.instance_of?(self.class)\n %w{antecedent num_antecedent_transactions \n support consequent confidence}.each do |key|\n return false unless object.send(key) == self.send(key)\n end\n return true\n else\n return false\n end\n end",
"def test_communication_agent_class_is_person_or_organisation\n orig_class = @communication.communication_agent_class\n \n @communication.communication_agent_class = 'A'\n assert [email protected]\n \n @communication.communication_agent_class = 'O'\n assert @communication.save\n \n @communication.communication_agent_class = orig_class\n assert @communication.save\n end",
"def test_multiple_updates_on_same_object\n # we start with dhh as owner and alexander as user/creator\n @presentation.name = \"new name\"\n @presentation.owner = @alexander\n @presentation.save\n \n assert_equal \"new name\", @presentation.name\n assert_equal @alexander, @presentation.owner\n assert_equal @alexander, @presentation.user\n \n assert [email protected]_owner_of?(@presentation)\n assert @alexander.is_owner_of?(@presentation)\n \n # ---- owner is now alexander, user/creator also alexander\n \n @presentation.name = \"new name 2\"\n @presentation.save\n \n assert_equal \"new name 2\", @presentation.name\n assert_equal @alexander, @presentation.owner\n assert_equal @alexander, @presentation.user\n \n assert [email protected]_owner_of?(@presentation)\n assert @alexander.is_owner_of?(@presentation)\n \n assert [email protected]_creator_of?(@presentation)\n assert @alexander.is_creator_of?(@presentation)\n \n # --- no change. owner: alexander, user/creator: alexander.\n \n @presentation.name = \"new name 3\"\n @presentation.user = @dhh\n @presentation.save\n \n assert_equal \"new name 3\", @presentation.name\n assert_equal @alexander, @presentation.owner\n assert_equal @dhh, @presentation.user\n \n assert [email protected]_owner_of?(@presentation)\n assert @alexander.is_owner_of?(@presentation)\n \n assert [email protected]_creator_of?(@presentation)\n assert @dhh.is_creator_of?(@presentation)\n \n # --- owner is still alexander, but user/creator is now dhh.\n \n @presentation.name = \"new name 4\"\n @presentation.owner = @dhh\n @presentation.save\n \n assert_equal \"new name 4\", @presentation.name\n assert_equal @dhh, @presentation.owner\n assert_equal @dhh, @presentation.user\n \n assert [email protected]_owner_of?(@presentation)\n assert @dhh.is_owner_of?(@presentation)\n \n assert [email protected]_creator_of?(@presentation)\n assert @dhh.is_creator_of?(@presentation)\n \n # --- owner is now also dhh, user/creator is still dhh.\n \n @presentation.name = \"new name 5\"\n @presentation.owner = @alexander\n @presentation.save\n # @presentation.reload\n \n assert_equal \"new name 5\", @presentation.name\n assert_equal @alexander, @presentation.owner\n assert_equal @dhh, @presentation.user\n \n assert [email protected]_owner_of?(@presentation)\n assert @alexander.is_owner_of?(@presentation)\n \n assert [email protected]_creator_of?(@presentation)\n assert @dhh.is_creator_of?(@presentation)\n \n \n end",
"def owned_by? a_user\n a_user == user\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n token == o.token &&\n tipo == o.tipo &&\n id_cliente == o.id_cliente &&\n id_fornitore == o.id_fornitore &&\n nome == o.nome &&\n indirizzo_via == o.indirizzo_via &&\n indirizzo_cap == o.indirizzo_cap &&\n indirizzo_citta == o.indirizzo_citta &&\n indirizzo_provincia == o.indirizzo_provincia &&\n indirizzo_extra == o.indirizzo_extra &&\n paese == o.paese &&\n lingua == o.lingua &&\n piva == o.piva &&\n cf == o.cf &&\n numero == o.numero &&\n valuta == o.valuta &&\n valuta_cambio == o.valuta_cambio &&\n prezzi_ivati == o.prezzi_ivati &&\n importo_netto == o.importo_netto &&\n importo_iva == o.importo_iva &&\n importo_totale == o.importo_totale &&\n rivalsa == o.rivalsa &&\n importo_rivalsa == o.importo_rivalsa &&\n cassa == o.cassa &&\n importo_cassa == o.importo_cassa &&\n rit_acconto == o.rit_acconto &&\n imponibile_ritenuta == o.imponibile_ritenuta &&\n importo_rit_acconto == o.importo_rit_acconto &&\n rit_altra == o.rit_altra &&\n importo_rit_altra == o.importo_rit_altra &&\n marca_bollo == o.marca_bollo &&\n oggetto_visibile == o.oggetto_visibile &&\n oggetto_interno == o.oggetto_interno &&\n centro_ricavo == o.centro_ricavo &&\n centro_costo == o.centro_costo &&\n note == o.note &&\n nascondi_scadenza == o.nascondi_scadenza &&\n ddt == o.ddt &&\n ftacc == o.ftacc &&\n id_template == o.id_template &&\n ddt_id_template == o.ddt_id_template &&\n ftacc_id_template == o.ftacc_id_template &&\n mostra_info_pagamento == o.mostra_info_pagamento &&\n metodo_pagamento == o.metodo_pagamento &&\n metodo_titolo_n == o.metodo_titolo_n &&\n metodo_desc_n == o.metodo_desc_n &&\n mostra_totali == o.mostra_totali &&\n mostra_bottone_paypal == o.mostra_bottone_paypal &&\n mostra_bottone_bonifico == o.mostra_bottone_bonifico &&\n mostra_bottone_notifica == o.mostra_bottone_notifica &&\n lista_articoli == o.lista_articoli &&\n lista_pagamenti == o.lista_pagamenti &&\n ddt_numero == o.ddt_numero &&\n ddt_colli == o.ddt_colli &&\n ddt_peso == o.ddt_peso &&\n ddt_causale == o.ddt_causale &&\n ddt_luogo == o.ddt_luogo &&\n ddt_trasportatore == o.ddt_trasportatore &&\n ddt_annotazioni == o.ddt_annotazioni &&\n link_doc == o.link_doc &&\n link_ddt == o.link_ddt &&\n link_ftacc == o.link_ftacc &&\n link_allegato == o.link_allegato &&\n bloccato == o.bloccato &&\n pa == o.pa &&\n pa_tipo_cliente == o.pa_tipo_cliente &&\n pa_tipo == o.pa_tipo &&\n pa_numero == o.pa_numero &&\n pa_cup == o.pa_cup &&\n pa_cig == o.pa_cig &&\n pa_codice == o.pa_codice &&\n pa_esigibilita == o.pa_esigibilita &&\n pa_modalita_pagamento == o.pa_modalita_pagamento &&\n pa_istituto_credito == o.pa_istituto_credito &&\n pa_iban == o.pa_iban &&\n pa_beneficiario == o.pa_beneficiario &&\n pa_ts == o.pa_ts &&\n pa_ts_stato == o.pa_ts_stato &&\n split_payment == o.split_payment\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n mandate_id == o.mandate_id &&\n title == o.title &&\n legal_informations == o.legal_informations &&\n unique_mandate_reference == o.unique_mandate_reference &&\n mandate_status == o.mandate_status &&\n user_id == o.user_id &&\n debtor_name == o.debtor_name &&\n debtor_address == o.debtor_address &&\n debtor_city == o.debtor_city &&\n debtor_zip_code == o.debtor_zip_code &&\n debtor_country == o.debtor_country &&\n debtor_iban == o.debtor_iban &&\n debtor_bic == o.debtor_bic &&\n sequence_type == o.sequence_type &&\n creditor_name == o.creditor_name &&\n sepa_creditor_identifier == o.sepa_creditor_identifier &&\n creditor_address == o.creditor_address &&\n creditor_city == o.creditor_city &&\n creditor_zip_code == o.creditor_zip_code &&\n creditor_country == o.creditor_country &&\n signature_date == o.signature_date &&\n debtor_signature_ip == o.debtor_signature_ip &&\n signed == o.signed &&\n debtor_identification_code == o.debtor_identification_code &&\n debtor_reference_party_name == o.debtor_reference_party_name &&\n debtor_reference_identification_code == o.debtor_reference_identification_code &&\n creditor_reference_party_name == o.creditor_reference_party_name &&\n creditor_reference_identification_code == o.creditor_reference_identification_code &&\n contract_identification_number == o.contract_identification_number &&\n contract_description == o.contract_description &&\n is_paper == o.is_paper &&\n sdd_type == o.sdd_type &&\n revocation_signature_date == o.revocation_signature_date &&\n created_ip == o.created_ip &&\n created_date == o.created_date &&\n modified_date == o.modified_date &&\n user_id_ultimate_creditor == o.user_id_ultimate_creditor\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n _info == o._info &&\n actual_end == o.actual_end &&\n actual_hours == o.actual_hours &&\n actual_start == o.actual_start &&\n agreement == o.agreement &&\n bill_expenses == o.bill_expenses &&\n billing_amount == o.billing_amount &&\n billing_attention == o.billing_attention &&\n billing_method == o.billing_method &&\n billing_rate_type == o.billing_rate_type &&\n billing_terms == o.billing_terms &&\n bill_products == o.bill_products &&\n bill_project_after_closed_flag == o.bill_project_after_closed_flag &&\n bill_time == o.bill_time &&\n bill_to_company == o.bill_to_company &&\n bill_to_contact == o.bill_to_contact &&\n bill_to_site == o.bill_to_site &&\n bill_unapproved_time_and_expense == o.bill_unapproved_time_and_expense &&\n board == o.board &&\n budget_analysis == o.budget_analysis &&\n budget_flag == o.budget_flag &&\n budget_hours == o.budget_hours &&\n business_unit_id == o.business_unit_id &&\n company == o.company &&\n contact == o.contact &&\n customer_po == o.customer_po &&\n description == o.description &&\n downpayment == o.downpayment &&\n estimated_end == o.estimated_end &&\n estimated_expense_revenue == o.estimated_expense_revenue &&\n estimated_hours == o.estimated_hours &&\n estimated_product_revenue == o.estimated_product_revenue &&\n estimated_start == o.estimated_start &&\n estimated_time_revenue == o.estimated_time_revenue &&\n expense_approver == o.expense_approver &&\n include_dependencies_flag == o.include_dependencies_flag &&\n include_estimates_flag == o.include_estimates_flag &&\n location_id == o.location_id &&\n manager == o.manager &&\n name == o.name &&\n opportunity == o.opportunity &&\n project_template_id == o.project_template_id &&\n restrict_down_payment_flag == o.restrict_down_payment_flag &&\n scheduled_end == o.scheduled_end &&\n scheduled_hours == o.scheduled_hours &&\n scheduled_start == o.scheduled_start &&\n ship_to_company == o.ship_to_company &&\n ship_to_contact == o.ship_to_contact &&\n ship_to_site == o.ship_to_site &&\n site == o.site &&\n status == o.status &&\n time_approver == o.time_approver &&\n type == o.type\n end",
"def author?(user)\n self.user == user\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n __meta == o.__meta &&\n created_at == o.created_at &&\n updated_at == o.updated_at &&\n customer == o.customer &&\n reusable == o.reusable &&\n status == o.status &&\n token == o.token\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n class_id == o.class_id &&\n object_type == o.object_type &&\n contract == o.contract &&\n contract_status == o.contract_status &&\n contract_status_reason == o.contract_status_reason &&\n contract_updated_time == o.contract_updated_time &&\n covered_product_line_end_date == o.covered_product_line_end_date &&\n device_id == o.device_id &&\n device_type == o.device_type &&\n end_customer == o.end_customer &&\n end_user_global_ultimate == o.end_user_global_ultimate &&\n is_valid == o.is_valid &&\n item_type == o.item_type &&\n maintenance_purchase_order_number == o.maintenance_purchase_order_number &&\n maintenance_sales_order_number == o.maintenance_sales_order_number &&\n platform_type == o.platform_type &&\n product == o.product &&\n purchase_order_number == o.purchase_order_number &&\n reseller_global_ultimate == o.reseller_global_ultimate &&\n sales_order_number == o.sales_order_number &&\n service_description == o.service_description &&\n service_end_date == o.service_end_date &&\n service_level == o.service_level &&\n service_sku == o.service_sku &&\n service_start_date == o.service_start_date &&\n state_contract == o.state_contract &&\n warranty_end_date == o.warranty_end_date &&\n warranty_type == o.warranty_type &&\n registered_device == o.registered_device &&\n source == o.source\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n deleted == o.deleted &&\n edited_by_user == o.edited_by_user &&\n email_communication_sequence_email_uuid == o.email_communication_sequence_email_uuid &&\n email_communication_sequence_uuid == o.email_communication_sequence_uuid &&\n email_container_cjson == o.email_container_cjson &&\n email_container_cjson_last_modified_dts == o.email_container_cjson_last_modified_dts &&\n email_template_vm_path == o.email_template_vm_path &&\n filter_profile_equation_json == o.filter_profile_equation_json &&\n individually_render == o.individually_render &&\n library_item_oid == o.library_item_oid &&\n magic_link == o.magic_link &&\n merchant_id == o.merchant_id &&\n pending_review == o.pending_review &&\n preview_text == o.preview_text &&\n rejected == o.rejected &&\n requires_review == o.requires_review &&\n screenshot_large_full_url == o.screenshot_large_full_url &&\n screenshot_large_viewport_url == o.screenshot_large_viewport_url &&\n screenshot_small_full_url == o.screenshot_small_full_url &&\n screenshot_small_viewport_url == o.screenshot_small_viewport_url &&\n smart_sending == o.smart_sending &&\n storefront_oid == o.storefront_oid &&\n subject == o.subject &&\n suspended_for_spam == o.suspended_for_spam &&\n transactional_email == o.transactional_email &&\n version == o.version\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n tls_ca_cert == o.tls_ca_cert &&\n tls_client_cert == o.tls_client_cert &&\n tls_client_key == o.tls_client_key &&\n tls_cert_hostname == o.tls_cert_hostname &&\n use_tls == o.use_tls &&\n created_at == o.created_at &&\n deleted_at == o.deleted_at &&\n updated_at == o.updated_at &&\n service_id == o.service_id &&\n version == o.version &&\n name == o.name &&\n shield == o.shield &&\n request_condition == o.request_condition &&\n tls_ciphers == o.tls_ciphers &&\n tls_sni_hostname == o.tls_sni_hostname &&\n min_tls_version == o.min_tls_version &&\n max_tls_version == o.max_tls_version &&\n healthcheck == o.healthcheck &&\n comment == o.comment &&\n type == o.type &&\n override_host == o.override_host &&\n between_bytes_timeout == o.between_bytes_timeout &&\n connect_timeout == o.connect_timeout &&\n first_byte_timeout == o.first_byte_timeout &&\n max_conn_default == o.max_conn_default &&\n tls_check_cert == o.tls_check_cert &&\n id == o.id &&\n quorum == o.quorum\n end",
"def object_owner_for_resource?(object)\n object.user == current_user\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account == o.account &&\n description == o.description &&\n host_restriction == o.host_restriction &&\n id == o.id &&\n name == o.name &&\n port_restriction == o.port_restriction &&\n site_assignment == o.site_assignment &&\n sites == o.sites\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n ticker == o.ticker &&\n figi_ticker == o.figi_ticker &&\n ric == o.ric &&\n isin == o.isin &&\n sedol == o.sedol &&\n exchange_mic == o.exchange_mic &&\n sponsor == o.sponsor &&\n type == o.type &&\n description == o.description &&\n inception_date == o.inception_date &&\n data_change_date == o.data_change_date &&\n close_date == o.close_date &&\n is_live_listed == o.is_live_listed &&\n legal_structure == o.legal_structure &&\n intraday_nav_ticker == o.intraday_nav_ticker &&\n primary_ticker == o.primary_ticker &&\n primary_ticker_country_code == o.primary_ticker_country_code &&\n primary_listing_region == o.primary_listing_region &&\n net_expense_ratio == o.net_expense_ratio &&\n asset_class == o.asset_class &&\n other_asset_types == o.other_asset_types &&\n market_cap_range == o.market_cap_range &&\n holds_only_nyse_stocks == o.holds_only_nyse_stocks &&\n holds_only_nasdaq_stocks == o.holds_only_nasdaq_stocks &&\n growth_value_tilt == o.growth_value_tilt &&\n growth_type == o.growth_type &&\n value_type == o.value_type &&\n sector == o.sector &&\n industry == o.industry &&\n sub_industry == o.sub_industry &&\n cross_sector_theme == o.cross_sector_theme &&\n natural_resources_type == o.natural_resources_type &&\n excludes_financials == o.excludes_financials &&\n excludes_technology == o.excludes_technology &&\n us_or_excludes_us == o.us_or_excludes_us &&\n developed_emerging == o.developed_emerging &&\n specialized_region == o.specialized_region &&\n continent == o.continent &&\n latin_america_sub_group == o.latin_america_sub_group &&\n europe_sub_group == o.europe_sub_group &&\n asia_sub_group == o.asia_sub_group &&\n specific_country == o.specific_country &&\n china_listing_location == o.china_listing_location &&\n us_state == o.us_state &&\n real_estate == o.real_estate &&\n index_weighting_scheme == o.index_weighting_scheme &&\n market_cap_weighting_type == o.market_cap_weighting_type &&\n fundamental_weighting_type == o.fundamental_weighting_type &&\n dividend_weighting_type == o.dividend_weighting_type &&\n bond_type == o.bond_type &&\n government_bond_types == o.government_bond_types &&\n municipal_bond_region == o.municipal_bond_region &&\n municipal_vrdo == o.municipal_vrdo &&\n mortgage_bond_types == o.mortgage_bond_types &&\n bond_tax_status == o.bond_tax_status &&\n credit_quality == o.credit_quality &&\n average_maturity == o.average_maturity &&\n specific_maturity_year == o.specific_maturity_year &&\n bond_currency_denomination == o.bond_currency_denomination &&\n laddered == o.laddered &&\n zero_coupon == o.zero_coupon &&\n floating_rate == o.floating_rate &&\n build_america_bonds == o.build_america_bonds &&\n commodity_types == o.commodity_types &&\n energy_type == o.energy_type &&\n agricultural_type == o.agricultural_type &&\n metal_type == o.metal_type &&\n inverse_leveraged == o.inverse_leveraged &&\n target_date_multi_asset_type == o.target_date_multi_asset_type &&\n currency_hedged == o.currency_hedged &&\n currency_pair == o.currency_pair &&\n social_environmental_type == o.social_environmental_type &&\n clean_energy_type == o.clean_energy_type &&\n dividend_type == o.dividend_type &&\n regular_dividend_payor_type == o.regular_dividend_payor_type &&\n holds_ml_ps == o.holds_ml_ps &&\n holds_preferred_stock == o.holds_preferred_stock &&\n holds_closed_end_funds == o.holds_closed_end_funds &&\n quant_strategies_type == o.quant_strategies_type &&\n other_quant_models == o.other_quant_models &&\n hedge_fund_type == o.hedge_fund_type &&\n derivatives_based == o.derivatives_based &&\n holds_ad_rs == o.holds_ad_rs &&\n index_linked == o.index_linked &&\n includes_short_exposure == o.includes_short_exposure &&\n index_name == o.index_name &&\n parent_index == o.parent_index &&\n index_family == o.index_family &&\n broader_index_family == o.broader_index_family &&\n index_provider == o.index_provider &&\n fund_family == o.fund_family &&\n index_ticker == o.index_ticker &&\n etn_issuing_bank == o.etn_issuing_bank &&\n etn_maturity_date == o.etn_maturity_date &&\n livestock == o.livestock &&\n dynamic_futures_roll == o.dynamic_futures_roll &&\n index_provider_code == o.index_provider_code &&\n single_category_designation == o.single_category_designation &&\n registered_countries == o.registered_countries &&\n issuing_entity_country_code == o.issuing_entity_country_code &&\n ucits == o.ucits &&\n replication_structure == o.replication_structure &&\n domicile == o.domicile &&\n base_currency == o.base_currency &&\n listing_currency == o.listing_currency &&\n fund_listing_date == o.fund_listing_date &&\n listing_country_code == o.listing_country_code &&\n listing_region == o.listing_region &&\n smartvs_traditional_beta == o.smartvs_traditional_beta &&\n smartvs_traditional_beta_level2 == o.smartvs_traditional_beta_level2 &&\n income_category == o.income_category &&\n etp_structure_type == o.etp_structure_type &&\n month_end_assets == o.month_end_assets &&\n etf_portfolio_turnover == o.etf_portfolio_turnover &&\n firstbridge_id == o.firstbridge_id &&\n firstbridge_parent_id == o.firstbridge_parent_id &&\n number_of_holdings == o.number_of_holdings\n end",
"def has_common_coauthor_with(other_authors)\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n objective == o.objective &&\n property_types == o.property_types &&\n status == o.status &&\n sale_mode == o.sale_mode &&\n channel == o.channel &&\n address_parts == o.address_parts &&\n advertiser_identifiers == o.advertiser_identifiers &&\n apm_identifiers == o.apm_identifiers &&\n bathrooms == o.bathrooms &&\n bedrooms == o.bedrooms &&\n building_area == o.building_area &&\n building_area_sqm == o.building_area_sqm &&\n carspaces == o.carspaces &&\n date_available == o.date_available &&\n date_created == o.date_created &&\n date_updated == o.date_updated &&\n date_minor_updated == o.date_minor_updated &&\n date_listed == o.date_listed &&\n date_purged == o.date_purged &&\n description == o.description &&\n dev_project_id == o.dev_project_id &&\n energy_efficiency_rating == o.energy_efficiency_rating &&\n features == o.features &&\n geo_location == o.geo_location &&\n headline == o.headline &&\n id == o.id &&\n inspection_details == o.inspection_details &&\n is_new_development == o.is_new_development &&\n land_area == o.land_area &&\n land_area_sqm == o.land_area_sqm &&\n media == o.media &&\n price_details == o.price_details &&\n property_id == o.property_id &&\n provider_details == o.provider_details &&\n rental_details == o.rental_details &&\n sale_details == o.sale_details &&\n is_withdrawn == o.is_withdrawn &&\n seo_url == o.seo_url &&\n error_message == o.error_message &&\n virtual_tour_url == o.virtual_tour_url &&\n homepass_enabled == o.homepass_enabled &&\n statement_of_information == o.statement_of_information &&\n number_of_dwellings == o.number_of_dwellings &&\n highlights == o.highlights\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n created == o.created &&\n changed_by == o.changed_by &&\n updated == o.updated &&\n id == o.id &&\n account_id == o.account_id &&\n subscription_id == o.subscription_id &&\n invoice_id == o.invoice_id &&\n from == o.from &&\n to == o.to &&\n cc == o.cc &&\n bcc == o.bcc &&\n subject == o.subject &&\n html == o.html &&\n attachment_filename == o.attachment_filename &&\n attachment_html == o.attachment_html &&\n plain == o.plain &&\n sent == o.sent &&\n state == o.state &&\n deleted == o.deleted &&\n header_url == o.header_url &&\n salutation == o.salutation &&\n paragraph1 == o.paragraph1 &&\n paragraph2 == o.paragraph2 &&\n footer_information == o.footer_information &&\n signoff == o.signoff &&\n emai_subscription_type == o.emai_subscription_type &&\n notification_id == o.notification_id &&\n organization_id == o.organization_id\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n invoice_number == o.invoice_number &&\n type == o.type &&\n status == o.status &&\n company == o.company &&\n bill_to_company == o.bill_to_company &&\n ship_to_company == o.ship_to_company &&\n apply_to_type == o.apply_to_type &&\n apply_to_id == o.apply_to_id &&\n attention == o.attention &&\n billing_site == o.billing_site &&\n shipping_site == o.shipping_site &&\n billing_terms == o.billing_terms &&\n reference == o.reference &&\n customer_po == o.customer_po &&\n template_setup_id == o.template_setup_id &&\n email_template_id == o.email_template_id &&\n add_to_batch_email_list == o.add_to_batch_email_list &&\n date == o.date &&\n restrict_downpayment_flag == o.restrict_downpayment_flag &&\n location_id == o.location_id &&\n department_id == o.department_id &&\n territory_id == o.territory_id &&\n top_comment == o.top_comment &&\n bottom_comment == o.bottom_comment &&\n taxable_flag == o.taxable_flag &&\n tax_code == o.tax_code &&\n internal_notes == o.internal_notes &&\n downpayment_previously_taxed_flag == o.downpayment_previously_taxed_flag &&\n service_total == o.service_total &&\n due_date == o.due_date &&\n expense_total == o.expense_total &&\n product_total == o.product_total &&\n previous_progress_applied == o.previous_progress_applied &&\n service_adjustment_amount == o.service_adjustment_amount &&\n agreement_amount == o.agreement_amount &&\n downpayment_applied == o.downpayment_applied &&\n subtotal == o.subtotal &&\n total == o.total &&\n remaining_downpayment == o.remaining_downpayment &&\n sales_tax == o.sales_tax &&\n adjustment_reason == o.adjustment_reason &&\n adjusted_by == o.adjusted_by &&\n payments == o.payments &&\n credits == o.credits &&\n balance == o.balance &&\n special_invoice_flag == o.special_invoice_flag\n end",
"def core \n self.service.organization\n end",
"def is_authorized_to_edit_offerings_at location\n if location.is_a? Store\n @a = Authorization.find_by_target_id_and_target_type_and_user_id(location, 'Store', id)\n end \n location = location.id if location.is_a? Location\n return true if is_authorized_to_create_offerings_at location\n @a ||= Authorization.find_by_target_id_and_target_type_and_user_id(location, 'Location', id)\n @a && [1, 2, 10, 20].include(@a.authorization_type)\n end",
"def can_refresh?(other)\n mrrt? && (authority == other.authority) &&\n (user_info == other.user_info) && (client_id == other.client_id)\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n name == o.name &&\n placement == o.placement &&\n response_condition == o.response_condition &&\n format == o.format &&\n format_version == o.format_version &&\n region == o.region &&\n token == o.token &&\n created_at == o.created_at &&\n deleted_at == o.deleted_at &&\n updated_at == o.updated_at &&\n service_id == o.service_id &&\n version == o.version\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n sales_activity == o.sales_activity &&\n service_team == o.service_team &&\n company_team == o.company_team &&\n workflow == o.workflow &&\n status_workflow == o.status_workflow &&\n service_template == o.service_template &&\n opportunity == o.opportunity &&\n sales_team == o.sales_team &&\n project_manager == o.project_manager &&\n knowledge_baseb_article == o.knowledge_baseb_article &&\n my_company_president_role == o.my_company_president_role &&\n my_company_coo_role == o.my_company_coo_role &&\n my_company_controller_role == o.my_company_controller_role &&\n my_company_dispatch_role == o.my_company_dispatch_role &&\n my_company_service_manager_role == o.my_company_service_manager_role &&\n my_company_duty_manager_role == o.my_company_duty_manager_role &&\n department_manager == o.department_manager &&\n dispatch_member == o.dispatch_member &&\n service_manager == o.service_manager &&\n duty_manager == o.duty_manager &&\n delete_open_time_sheets_flag == o.delete_open_time_sheets_flag\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n auth_provider_x509_cert_url == o.auth_provider_x509_cert_url &&\n auth_uri == o.auth_uri &&\n automute == o.automute &&\n client_email == o.client_email &&\n client_id == o.client_id &&\n client_x509_cert_url == o.client_x509_cert_url &&\n errors == o.errors &&\n host_filters == o.host_filters &&\n is_cspm_enabled == o.is_cspm_enabled &&\n private_key == o.private_key &&\n private_key_id == o.private_key_id &&\n project_id == o.project_id &&\n token_uri == o.token_uri &&\n type == o.type\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n anchor == o.anchor &&\n anchor_case_sensitive == o.anchor_case_sensitive &&\n anchor_horizontal_alignment == o.anchor_horizontal_alignment &&\n anchor_ignore_if_not_present == o.anchor_ignore_if_not_present &&\n anchor_match_whole_word == o.anchor_match_whole_word &&\n anchor_units == o.anchor_units &&\n anchor_x_offset == o.anchor_x_offset &&\n anchor_y_offset == o.anchor_y_offset &&\n bold == o.bold &&\n collaborative == o.collaborative &&\n conceal_value_on_document == o.conceal_value_on_document &&\n created_by_display_name == o.created_by_display_name &&\n created_by_user_id == o.created_by_user_id &&\n custom_tab_id == o.custom_tab_id &&\n disable_auto_size == o.disable_auto_size &&\n editable == o.editable &&\n font == o.font &&\n font_color == o.font_color &&\n font_size == o.font_size &&\n height == o.height &&\n included_in_email == o.included_in_email &&\n initial_value == o.initial_value &&\n italic == o.italic &&\n items == o.items &&\n last_modified == o.last_modified &&\n last_modified_by_display_name == o.last_modified_by_display_name &&\n last_modified_by_user_id == o.last_modified_by_user_id &&\n locked == o.locked &&\n maximum_length == o.maximum_length &&\n merge_field == o.merge_field &&\n name == o.name &&\n payment_item_code == o.payment_item_code &&\n payment_item_description == o.payment_item_description &&\n payment_item_name == o.payment_item_name &&\n required == o.required &&\n scale_value == o.scale_value &&\n selected == o.selected &&\n shared == o.shared &&\n stamp_type == o.stamp_type &&\n stamp_type_metadata == o.stamp_type_metadata &&\n tab_label == o.tab_label &&\n type == o.type &&\n underline == o.underline &&\n validation_message == o.validation_message &&\n validation_pattern == o.validation_pattern &&\n width == o.width\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n access_complexity == o.access_complexity &&\n access_vector == o.access_vector &&\n authentication == o.authentication &&\n availability_impact == o.availability_impact &&\n confidentiality_impact == o.confidentiality_impact &&\n exploit_score == o.exploit_score &&\n impact_score == o.impact_score &&\n integrity_impact == o.integrity_impact &&\n score == o.score &&\n vector == o.vector\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n address == o.address &&\n timezone == o.timezone &&\n capabilities == o.capabilities &&\n status == o.status &&\n created_at == o.created_at &&\n merchant_id == o.merchant_id &&\n country == o.country &&\n language_code == o.language_code &&\n currency == o.currency &&\n phone_number == o.phone_number &&\n business_name == o.business_name &&\n type == o.type &&\n website_url == o.website_url\n end",
"def secure_compare(a, b); end",
"def secure_compare(a, b); end",
"def secure_compare(a, b); end",
"def authorized?(user)\n current_user == user\nend",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account_id == o.account_id &&\n campaign_id == o.campaign_id &&\n csp_id == o.csp_id &&\n reseller_id == o.reseller_id &&\n status == o.status &&\n create_date == o.create_date &&\n auto_renewal == o.auto_renewal &&\n billed_date == o.billed_date &&\n brand_id == o.brand_id &&\n usecase == o.usecase &&\n sub_usecases == o.sub_usecases &&\n description == o.description &&\n embedded_link == o.embedded_link &&\n embedded_phone == o.embedded_phone &&\n affiliate_marketing == o.affiliate_marketing &&\n number_pool == o.number_pool &&\n age_gated == o.age_gated &&\n direct_lending == o.direct_lending &&\n subscriber_optin == o.subscriber_optin &&\n subscriber_optout == o.subscriber_optout &&\n subscriber_help == o.subscriber_help &&\n sample1 == o.sample1 &&\n sample2 == o.sample2 &&\n sample3 == o.sample3 &&\n sample4 == o.sample4 &&\n sample5 == o.sample5 &&\n message_flow == o.message_flow &&\n help_message == o.help_message &&\n reference_id == o.reference_id &&\n mock == o.mock &&\n next_renewal_or_expiration_date == o.next_renewal_or_expiration_date\n end",
"def requestor; organization; end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n description == o.description &&\n routing_number == o.routing_number &&\n account_number == o.account_number &&\n account_type == o.account_type &&\n signatory == o.signatory &&\n metadata == o.metadata &&\n id == o.id &&\n signature_url == o.signature_url &&\n bank_name == o.bank_name &&\n verified == o.verified &&\n date_created == o.date_created &&\n date_modified == o.date_modified &&\n deleted == o.deleted &&\n object == o.object\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n key == o.key &&\n name == o.name &&\n description == o.description &&\n kind == o.kind &&\n creation_date == o.creation_date &&\n include_in_snippet == o.include_in_snippet &&\n temporary == o.temporary &&\n maintainer_id == o.maintainer_id &&\n tags == o.tags &&\n variations == o.variations &&\n goal_ids == o.goal_ids &&\n _version == o._version &&\n custom_properties == o.custom_properties &&\n _links == o._links &&\n _maintainer == o._maintainer &&\n environments == o.environments &&\n archived_date == o.archived_date &&\n archived == o.archived &&\n client_side_availability == o.client_side_availability &&\n defaults == o.defaults\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n provider_name == o.provider_name &&\n host_name == o.host_name &&\n host_port == o.host_port &&\n host_ssl == o.host_ssl &&\n host_tls == o.host_tls &&\n host_no_cert_check == o.host_no_cert_check &&\n bind_dn == o.bind_dn &&\n bind_password == o.bind_password &&\n search_timeout == o.search_timeout &&\n admin_pool_max_active == o.admin_pool_max_active &&\n admin_pool_lookup_on_validate == o.admin_pool_lookup_on_validate &&\n user_pool_max_active == o.user_pool_max_active &&\n user_pool_lookup_on_validate == o.user_pool_lookup_on_validate &&\n user_base_dn == o.user_base_dn &&\n user_objectclass == o.user_objectclass &&\n user_id_attribute == o.user_id_attribute &&\n user_extra_filter == o.user_extra_filter &&\n user_make_dn_path == o.user_make_dn_path &&\n group_base_dn == o.group_base_dn &&\n group_objectclass == o.group_objectclass &&\n group_name_attribute == o.group_name_attribute &&\n group_extra_filter == o.group_extra_filter &&\n group_make_dn_path == o.group_make_dn_path &&\n group_member_attribute == o.group_member_attribute &&\n use_uid_for_ext_id == o.use_uid_for_ext_id &&\n customattributes == o.customattributes\n end",
"def ensure_author_orcid\n return if @resource.owner_author # the owner is already represented by an author with their orcid\n\n user = @resource.user\n\n this_author = @resource.authors.where(author_first_name: user.first_name, author_last_name: user.last_name).first\n\n if this_author.present?\n this_author.update(author_orcid: user.orcid)\n return\n end\n\n StashEngine::Author.create(\n author_first_name: user.first_name,\n author_last_name: user.last_name,\n author_orcid: user.orcid,\n author_email: user.email,\n resource_id: @resource.id\n )\n end",
"def verify_authorizations(test_data)\n authorizations = test_data[UseOfCollections::AUTHORIZATION_GRP.name] || [UseOfCollections.empty_authorization]\n authorizations.each_with_index do |auth, index|\n verify_values_match(auth[UseOfCollections::AUTHORIZED_BY.name], element_value(authorized_by_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_DATE.name], element_value(authorization_date_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_NOTE.name], element_value(authorization_note_input index))\n verify_values_match(auth[UseOfCollections::AUTHORIZATION_STATUS.name], element_value(authorization_status_input index))\n end\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n type == o.type &&\n id == o.id &&\n timestamp == o.timestamp &&\n local_timestamp == o.local_timestamp &&\n local_timezone == o.local_timezone &&\n caller_id == o.caller_id &&\n service_url == o.service_url &&\n channel_id == o.channel_id &&\n from == o.from &&\n conversation == o.conversation &&\n recipient == o.recipient &&\n text_format == o.text_format &&\n attachment_layout == o.attachment_layout &&\n members_added == o.members_added &&\n members_removed == o.members_removed &&\n reactions_added == o.reactions_added &&\n reactions_removed == o.reactions_removed &&\n topic_name == o.topic_name &&\n history_disclosed == o.history_disclosed &&\n locale == o.locale &&\n text == o.text &&\n speak == o.speak &&\n input_hint == o.input_hint &&\n summary == o.summary &&\n suggested_actions == o.suggested_actions &&\n attachments == o.attachments &&\n entities == o.entities &&\n channel_data == o.channel_data &&\n action == o.action &&\n reply_to_id == o.reply_to_id &&\n label == o.label &&\n value_type == o.value_type &&\n value == o.value &&\n name == o.name &&\n relates_to == o.relates_to &&\n code == o.code &&\n expiration == o.expiration &&\n importance == o.importance &&\n delivery_mode == o.delivery_mode &&\n listen_for == o.listen_for &&\n text_highlights == o.text_highlights &&\n semantic_action == o.semantic_action\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n class_id == o.class_id &&\n object_type == o.object_type &&\n active_admin == o.active_admin &&\n days_left == o.days_left &&\n end_time == o.end_time &&\n enforce_mode == o.enforce_mode &&\n error_desc == o.error_desc &&\n evaluation_period == o.evaluation_period &&\n extra_evaluation == o.extra_evaluation &&\n license_count == o.license_count &&\n license_state == o.license_state &&\n license_type == o.license_type &&\n start_time == o.start_time &&\n trial_admin == o.trial_admin &&\n account_license_data == o.account_license_data && super(o)\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n change_number == o.change_number &&\n date_created == o.date_created &&\n date_modified == o.date_modified &&\n date_uploaded == o.date_uploaded &&\n content_uri == o.content_uri &&\n workspace == o.workspace &&\n created_by == o.created_by &&\n uploaded_by == o.uploaded_by &&\n content_type == o.content_type &&\n content_length == o.content_length &&\n system_type == o.system_type &&\n filename == o.filename &&\n page_count == o.page_count &&\n read == o.read &&\n caller_address == o.caller_address &&\n receiver_address == o.receiver_address &&\n tags == o.tags &&\n tag_values == o.tag_values &&\n attributes == o.attributes &&\n thumbnails == o.thumbnails &&\n upload_status == o.upload_status &&\n upload_destination_uri == o.upload_destination_uri &&\n upload_method == o.upload_method &&\n lock_info == o.lock_info &&\n acl == o.acl &&\n sharing_status == o.sharing_status &&\n sharing_uri == o.sharing_uri &&\n download_sharing_uri == o.download_sharing_uri &&\n self_uri == o.self_uri\n end",
"def test_methods_work_correctly_with_configuration\r\n perm1 = OpenStruct.new(:identifier => 'permissions.perm1')\r\n perm2 = OpenStruct.new(:identifier => 'permissions.perm2')\r\n anonymous_role = \r\n OpenStruct.new(\r\n {\r\n :identifier => 'roles.anonymous', \r\n :permissions => [ perm1, perm2 ],\r\n }\r\n )\r\n assert_equal [ anonymous_role ], @configured_user.roles\r\n assert_equal true, @configured_user.has_role?('roles.anonymous')\r\n assert_equal false, @configured_user.has_role?('roles.foo')\r\n\r\n assert_equal [ perm1, perm2 ], @configured_user.permissions\r\n assert_equal true, @configured_user.has_static_permission?('permissions.perm1')\r\n assert_equal true, @configured_user.has_static_permission?('permissions.perm2')\r\n assert_equal false, @configured_user.has_static_permission?('permissions.foo')\r\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n account_id == o.account_id &&\n product == o.product &&\n product_rate_plan == o.product_rate_plan &&\n organization_id == o.organization_id &&\n name == o.name &&\n description == o.description &&\n start == o.start &&\n _end == o._end &&\n state == o.state &&\n trial_end == o.trial_end &&\n type == o.type &&\n parent_id == o.parent_id &&\n aggregate_all_subscriptions_on_account == o.aggregate_all_subscriptions_on_account &&\n align_period_with_aggregating_subscription == o.align_period_with_aggregating_subscription &&\n pricing_component_quantities == o.pricing_component_quantities &&\n metadata == o.metadata &&\n payment_terms == o.payment_terms &&\n purchase_order == o.purchase_order &&\n contract_start == o.contract_start &&\n failed_payment_behaviour == o.failed_payment_behaviour &&\n prepayment_amount == o.prepayment_amount\n end",
"def article_owner?(obj)\n\t\t\tcurrent_user.id == obj.user_id\n\t\tend",
"def can_change_tom?\n self.active? or self.provisional?\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n id == o.id &&\n name == o.name &&\n prefix_suffix_option == o.prefix_suffix_option &&\n default_flag == o.default_flag &&\n inactive_flag == o.inactive_flag &&\n pre_payment_flag == o.pre_payment_flag &&\n invoice_pre_suffix == o.invoice_pre_suffix &&\n location_id == o.location_id &&\n business_unit_id == o.business_unit_id &&\n restrict_location_flag == o.restrict_location_flag &&\n restrict_department_flag == o.restrict_department_flag &&\n sla_id == o.sla_id &&\n application_units == o.application_units &&\n application_limit == o.application_limit &&\n application_cycle == o.application_cycle &&\n application_unlimited_flag == o.application_unlimited_flag &&\n one_time_flag == o.one_time_flag &&\n cover_agreement_time_flag == o.cover_agreement_time_flag &&\n cover_agreement_product_flag == o.cover_agreement_product_flag &&\n cover_agreement_expense_flag == o.cover_agreement_expense_flag &&\n cover_sales_tax_flag == o.cover_sales_tax_flag &&\n carry_over_unused_flag == o.carry_over_unused_flag &&\n allow_overruns_flag == o.allow_overruns_flag &&\n expired_days == o.expired_days &&\n limit == o.limit &&\n expire_when_zero == o.expire_when_zero &&\n charge_to_firm_flag == o.charge_to_firm_flag &&\n employee_comp_rate == o.employee_comp_rate &&\n employee_comp_not_exceed == o.employee_comp_not_exceed &&\n comp_hourly_rate == o.comp_hourly_rate &&\n comp_limit_amount == o.comp_limit_amount &&\n bill_cycle_id == o.bill_cycle_id &&\n bill_one_time_flag == o.bill_one_time_flag &&\n bill_terms_id == o.bill_terms_id &&\n invoicing_cycle == o.invoicing_cycle &&\n bill_amount == o.bill_amount &&\n taxable_flag == o.taxable_flag &&\n restrict_down_payment_flag == o.restrict_down_payment_flag &&\n invoice_description == o.invoice_description &&\n top_comment_flag == o.top_comment_flag &&\n bottom_comment_flag == o.bottom_comment_flag &&\n work_role == o.work_role &&\n work_type == o.work_type &&\n project_type_id == o.project_type_id &&\n invoice_template_setup_id == o.invoice_template_setup_id &&\n bill_time == o.bill_time &&\n bill_expenses == o.bill_expenses &&\n bill_products == o.bill_products &&\n billable_time_invoice_flag == o.billable_time_invoice_flag &&\n billable_expense_invoice_flag == o.billable_expense_invoice_flag &&\n billable_product_invoice_flag == o.billable_product_invoice_flag &&\n copy_work_roles_flag == o.copy_work_roles_flag &&\n copy_work_types_flag == o.copy_work_types_flag &&\n _info == o._info\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n author == o.author &&\n created == o.created &&\n icon == o.icon &&\n id == o.id &&\n integration_id == o.integration_id &&\n is_favorite == o.is_favorite &&\n is_read_only == o.is_read_only &&\n is_shared == o.is_shared &&\n modified == o.modified &&\n popularity == o.popularity &&\n tags == o.tags &&\n title == o.title &&\n type == o.type &&\n url == o.url\n end",
"def test_update_name_add_author_nondestructive_merge\n old_name = names(:mergeable_epithet_unauthored)\n new_name = names(:mergeable_epithet_authored)\n new_author = new_name.author\n name_count = Name.count\n params = {\n id: old_name.id,\n name: {\n text_name: old_name.text_name,\n author: new_author,\n rank: old_name.rank,\n deprecated: (old_name.deprecated ? \"true\" : \"false\")\n }\n }\n login(old_name.user.login)\n put(:update, params: params)\n\n assert_redirected_to(name_path(new_name.id))\n assert_flash_success\n assert_equal(new_author, new_name.reload.author)\n assert_no_emails\n assert_equal(name_count - 1, Name.count)\n assert_not(Name.exists?(old_name.id))\n end",
"def test_voter_as_authorized_actor\n election = Election.new\n voter = Voter.new\n voter.election = election\n as_anything_goes_user do \n voter.save!\n election.save!\n end\n # AuthorizedActor.current_actor = voter\n \n as_user(voter) do\n assert AuthorizedActor.current_actor.check_permissions_for_action_on_model(:vote, Election), \n \"Expected voter to be permitted to vote in election\"\n \n assert AuthorizedActor.current_actor.check_permissions_for_action_on_model(:belong_in, Election, election), \n \"Expected voter to belong_in the election it belongs_to\"\n \n assert AuthorizedActor.current_actor.check_permissions_for_action_on_model(:belong_in, Election, Proc.new{ election }), \n \"Expected voter to belong_in a Proc that returns the election it belongs_to\"\n \n assert !AuthorizedActor.current_actor.check_permissions_for_action_on_model(:belong_in, Election, nil), \n \"Expected voter to not belong_in a nil election\"\n \n assert !AuthorizedActor.current_actor.check_permissions_for_action_on_model(:belong_in, Election, Election.new), \n \"Expected voter to not belong_in an election it does not belong_to\"\n \n assert !AuthorizedActor.current_actor.check_permissions_for_action_on_model(:rig, Election), \n \"Expected voter NOT to be permitted to rig election\"\n end\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n unit_id == o.unit_id &&\n name == o.name &&\n archived == o.archived &&\n type == o.type &&\n enable_pos_targets == o.enable_pos_targets &&\n menu_id == o.menu_id &&\n ac_area_id == o.ac_area_id &&\n ac_area_exit_id == o.ac_area_exit_id &&\n menu_item_id == o.menu_item_id &&\n enable_payout == o.enable_payout &&\n tickets_use_cart == o.tickets_use_cart &&\n tickets_cart_max_size == o.tickets_cart_max_size &&\n tickets_allow_barcode_by_keyboard == o.tickets_allow_barcode_by_keyboard &&\n ticket_site_mapping_label_config == o.ticket_site_mapping_label_config &&\n tickets_swap_to_chip == o.tickets_swap_to_chip &&\n tickets_allow_search == o.tickets_allow_search &&\n tickets_emit_access_check == o.tickets_emit_access_check &&\n ac_check_sell_product == o.ac_check_sell_product &&\n ac_check_use_turnstyle == o.ac_check_use_turnstyle &&\n self_service_card_payment_type_id == o.self_service_card_payment_type_id &&\n self_service_cash_payment_type_id == o.self_service_cash_payment_type_id &&\n self_service_cashless_payment_type_id == o.self_service_cashless_payment_type_id &&\n payment_type_ids == o.payment_type_ids &&\n chip_ids == o.chip_ids\n end"
] | [
"0.5884113",
"0.57734025",
"0.57579345",
"0.56387544",
"0.56277317",
"0.5547639",
"0.5523812",
"0.54792064",
"0.5468909",
"0.5465693",
"0.5452924",
"0.54393137",
"0.5439201",
"0.5380313",
"0.5369564",
"0.5328425",
"0.5304993",
"0.52943856",
"0.5293179",
"0.5289431",
"0.52820367",
"0.5272385",
"0.52634126",
"0.5260638",
"0.52575225",
"0.5243082",
"0.5241167",
"0.5238069",
"0.5233196",
"0.5222723",
"0.5217216",
"0.5217216",
"0.52147657",
"0.52075416",
"0.5204196",
"0.5198548",
"0.51945573",
"0.51943094",
"0.5187103",
"0.51858383",
"0.5177545",
"0.5175667",
"0.51687765",
"0.51679105",
"0.5163146",
"0.5162752",
"0.5161808",
"0.515951",
"0.5157669",
"0.5155651",
"0.5155372",
"0.5151661",
"0.51497686",
"0.5149584",
"0.5149342",
"0.5146701",
"0.5144291",
"0.5142589",
"0.513295",
"0.51225597",
"0.51198715",
"0.5119668",
"0.5114356",
"0.51118773",
"0.5108628",
"0.5105252",
"0.5090189",
"0.50884026",
"0.5086198",
"0.5084865",
"0.50816435",
"0.5081606",
"0.5080512",
"0.5079869",
"0.50764465",
"0.50728923",
"0.5071614",
"0.50673556",
"0.5067276",
"0.5067276",
"0.5067276",
"0.50616264",
"0.5056752",
"0.50515866",
"0.5045349",
"0.50418913",
"0.50409263",
"0.5039529",
"0.50392133",
"0.5038884",
"0.5034227",
"0.5033374",
"0.502751",
"0.50262797",
"0.50256497",
"0.50231737",
"0.5020915",
"0.501044",
"0.5009601",
"0.50069255",
"0.5004611"
] | 0.0 | -1 |
Redirect to the stored path or a default | def redirect_to_stored(default='/')
return_to = session[:return_to] || default
session[:return_to] = nil
redirect return_to
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def redirect_to_stored_location_or(default)\n redirect_to(session[:forward_url] || default)\n session.delete(:forward_url)\n end",
"def redirect_path(name, default = nil)\n stored_redirect_path(name) || default || root_path\n end",
"def redirect_back_or_default(default)\n redirect_to(pop_stored_location || default)\n end",
"def redirect_back_or_default(default)\n redirect_to(pop_stored_location || default)\n end",
"def redirect_to_stored_or_default(default)\n if session['return-to'].nil?\n redirect_to default\n else\n redirect_to_url session['return-to']\n session['return-to'] = nil\n end\nend",
"def get_default_or_back_to path = nil\n # TODO: Should redirect to user feed\n path ||= root_path\n redirect_to path\n end",
"def redirect_back_or_default(default)\n redirect_to(location_stored? ? session[:return_to] : default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n redirect_to url_for_redirect(default)\n end",
"def redirect(path)\n throw :redirect, path\n end",
"def default\n lambda { res.redirect('/', 301) }\n end",
"def redirect_back_or_default(default, options = {})\n target = url_to_store(session[:return_to])\n (target = logged_in? ? home_url(current_user) : nil) if target == '{home}'\n #target = nil if target == APP_CONFIG.hostname || target == APP_CONFIG.hostname + '/'\n target = default unless target\n target = safe_redirect(target)\n session[:return_to] = nil\n return target if options[:find_target_only]\n redirect_to(target)\n end",
"def restore_location_or(default)\n redirect_to(session[:return_to] || default)\n session.delete(:return_to)\n end",
"def redirect_back_or_default(default)\n redirect_to(default)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url) #delete what is stored.\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url) # Delete the stored URL for next log in\n end",
"def redirect?; end",
"def redirect_to_forwarding_url_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_path\r\n !(@target =~ /invoice/i).nil? ? redirect_to(new_invoice_path) : set_reload_path\r\n end",
"def redirect_back_or_to(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or( default )\n\t\tredirect_to( session[:forwarding_url] || default )\n\t\tsession.delete( :forwarding_url )\n\tend",
"def redirect_back_or_default(default)\n loc = session[:return_to] || default\n session[:return_to] = nil\n redirect loc\n end",
"def redirect_back_or_default(default=root_path)\n redirect_to back_url(default)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n # The following deletion happens even though the redirect stastement is written first.\n # This is because the redirect doesn't actually happen until an explicit\n # return statement or until the end of a method.\n session.delete(:forwarding_url)\n end",
"def redirect_back_or_default(default=nil)\n default = self.default_route\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default )\n session.delete(:forwarding_url)\n end",
"def redirect_back_or_default(default = \"/\")\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def return_to_path_or(default_path)\n return session.delete(:return_to_path) if session[:return_to_path]\n default_path\n end",
"def hubssolib_redirect_back_or_default(default)\n url = hubssolib_get_return_to\n hubssolib_set_return_to(nil)\n\n redirect_to(url || default)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n \tredirect_to(session[:forwarding_url] || default)\n\t session.delete(:forwarding_url)\n\tend",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default )\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_to_target(default=nil)\n \n goto_url=params[:return_to] || session[:return_to] || default || \"/\"\n \n session[:return_to] = nil\n redirect_to(goto_url)\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url] || default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || root_path)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or_default(default)\n redirect_to(session[:request_uri] || default)\n session[:request_uri] = nil\n end",
"def redirect_internal() redirect_to \"/nothing\"; end",
"def get_redirect_path(default=root_path)\n if params.key? :redirect_path\n @redirect_path = params[:redirect_path]\n elsif not @vertical.nil?\n if @vertical.class == \"Assignment\"\n @redirect_path = show_assignment_path(@vertical)\n else\n @redirect_path = get_vertical_path(@vertical)\n end\n else\n @redirect_path = default\n end\n @redirect_path\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n\t\tredirect_to(session[:forwarding_url]||default)\n\t\tsession.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n\n\t\t# redirects user to page stored in session symbol or the\n\t\t# dafault location if return_ to is not set.\n\t\tredirect_to(session[:return_to] || default)\n\n\t\t# Deletes the session symbol return_to\n\t\tsession.delete(:return_to)\n\tend",
"def redirect_back_or(default)\n\t redirect_to(session[:forwarding_url] || default)\n\t session.delete(:forwarding_url)\n\tend",
"def redirect_back_or(default)\n redirect_to session[:forwarding_url] || default\n session.delete(:forwarding_url)\n end",
"def redirect(options = {})\r\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarind_url)\n end",
"def redirect_back_or_default(default)\n if session[:return_to].nil?\n redirect_to default\n else\n redirect_to session[:return_to]\n session[:return_to] = nil\n end\n end",
"def redirect_back_or_default(default)\n if session[:return_to].nil?\n redirect_to default\n else\n redirect_to session[:return_to]\n session[:return_to] = nil\n end\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default )\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n\t\tredirect_to(session[:return_to] || default)\n\t\tclear_return_to\n\tend",
"def redirect_back_or(default)\n\t\tredirect_to(session[:return_to] || default)\n\t\tclear_return_to\n\tend",
"def redirect_back_or_default(default)\n redirect(session[:return_to] || default)\n session[:return_to] = nil\n end",
"def redirect_back_or(default)\n \tredirect_to(session[:forwarding_url] || default)\n \tsession.delete(:forwarding_url)\n end",
"def redirect_back_or_default(default = url('/'))\n redirect session.delete(:return_to) || default\n end",
"def redirect_back_or_default(default)\n\t\tredirect_to(session[:return_to] || default)\n\t\tsession[:return_to] = nil\n\tend",
"def redirect_back_or_default(default)\n session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)\n session[:return_to] = nil\n end",
"def redirect_back_or_default(default)\n session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)\n session[:return_to] = nil\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end",
"def redirect_back_or(default)\n redirect_to(session[:forwarding_url] || default)\n session.delete(:forwarding_url)\n end"
] | [
"0.7685314",
"0.74524176",
"0.7273553",
"0.7263497",
"0.7078865",
"0.69759434",
"0.6954229",
"0.68746746",
"0.6843526",
"0.6836822",
"0.68191373",
"0.6817303",
"0.6790331",
"0.6761267",
"0.67529535",
"0.6739468",
"0.67341745",
"0.67171645",
"0.671073",
"0.67013484",
"0.669695",
"0.6689143",
"0.66829896",
"0.6678881",
"0.6674888",
"0.6674888",
"0.66745204",
"0.66733027",
"0.66555536",
"0.6651892",
"0.6649023",
"0.66367304",
"0.6633381",
"0.6633346",
"0.662528",
"0.66222996",
"0.66222996",
"0.66222996",
"0.66222996",
"0.66222996",
"0.6621648",
"0.6621648",
"0.6621648",
"0.6621648",
"0.6621648",
"0.6621648",
"0.6621648",
"0.66209936",
"0.6618034",
"0.6612852",
"0.66125494",
"0.6611953",
"0.6599557",
"0.6596725",
"0.6588305",
"0.65864676",
"0.6584624",
"0.65835166",
"0.6577709",
"0.6577709",
"0.65776205",
"0.65669984",
"0.65669984",
"0.6565025",
"0.6563091",
"0.6556616",
"0.65528166",
"0.65526044",
"0.65526044",
"0.65526044",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773",
"0.6551773"
] | 0.7871603 | 0 |
Automatically detect a URLMapped Rack application and prepend the correct prefix before sending the redirect | def redirect(location, *args)
unless request.path == request.path_info
path = request.path.split('/')
info = request.path_info.split('/')
prefix = (path - info).join('/')
location = File.join('/', prefix, location)
end
super(location, *args)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ensure_full_path_name\n if request.fullpath.match(/^\\/[trg]$/)\n redirect_to \"/#{Blog.translate_context_to_route(@context)}\", :status => '301'\n elsif request.fullpath.match(/^\\/s$/)\n redirect_to \"/real-estate-spotlight\", :status => '301'\n end\n end",
"def fixup_url\n unless @view.app.url.starts_with?('http')\n unless @view.app.url.starts_with?('www')\n @view.app.url = 'www.' << @view.app.url\n end\n @view.app.url = 'http://' << @view.app.url\n end\n @view.app.url\n end",
"def call new_env\n old = new_env['REQUEST_URI']\n new = new_env['REQUEST_URI'].gsub(DOTS_AND_SLASHES, '/'.freeze).gsub(DOTS, '.'.freeze)\n if new != old \n DA99.redirect new, 301\n else\n @app.call new_env\n end\n end",
"def rack_app\n ctx = @context\n proc do |env|\n request_ctx = ctx.child\n request_ctx.templates = {}\n\n # If there are trailing slashes in path, don't dispatch\n if match = env['PATH_INFO'].match(/^(.+)(?<!\\$)\\/$/)\n\n # Remove trailing slash in the path and redirect\n loc = match[1]\n loc << \"?#{env['QUERY_STRING']}\" unless env['QUERY_STRING'].empty?\n [301, {'Location' => loc, 'Content-Type' => 'text/html; charset=utf-8'}, []]\n\n else\n\n # Dispatch controller chain for the current path\n request_ctx.env = env\n result = ::Tanuki::ControllerBehavior.dispatch(request_ctx, ctx.i18n ? ::Tanuki::I18n : ctx.root_page,\n Rack::Utils.unescape(env['PATH_INFO']).force_encoding('UTF-8'))\n\n # Handle dispatch result\n case result[:type]\n when :redirect then\n [302, {'Location' => result[:location], 'Content-Type' => 'text/html; charset=utf-8'}, []]\n when :page then\n [200, {'Content-Type' => 'text/html; charset=utf-8'}, build_body(result[:controller], request_ctx)]\n else\n [404, {'Content-Type' => 'text/html; charset=utf-8'}, build_body(result[:controller], request_ctx)]\n end\n\n end # if\n\n end\n end",
"def call(env)\n request = ::Rack::Request.new(env)\n if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/\n response = ::Rack::Response.new\n response.redirect(request.path_info[0, request.path_info.size - 1], 302)\n response.finish\n else\n @root.call(request) || @default_app.call(request.env)\n end\n end",
"def add_application_url( url )\n if( url.match(%r/http/) || url.match(%r/ftp/) )\n url\n else\n url = APPLICATION_URL + url\n end\n end",
"def modify_uri\n uri = @request.uri\n @conf.aliases.each do |a|\n if uri.include? a\n uri = uri.sub(a, @conf.alias_path(a))\n end\n end\n if uri != @request.uri\n return uri\n end\n @conf.script_aliases.each do |a|\n if uri.include? a\n uri = uri.sub(a, @conf.script_alias_path(a))\n end\n end\n uri\n end",
"def call(env)\n request = Rack::Request.new(env)\n if redirect_trailing_slash? && (request.head? || request.get?) && request.path_info[-1] == ?/\n response = Rack::Response.new\n response.redirect(request.path_info[0, request.path_info.size - 1], 302)\n response.finish\n else\n response = recognize(request)\n env['router'] = self\n if response.is_a?(RoutingResponse)\n [response.status, response.headers, []]\n elsif response && response.route.dest && response.route.dest.respond_to?(:call)\n process_params(env, response)\n consume_path!(request, response) if response.partial_match?\n response.route.dest.call(env)\n else\n @default_app.call(env)\n end\n end\n end",
"def redirect_url(urls)\n urls.find do |url|\n url.present? && routable?(url)\n end || main_app.root_path\n end",
"def call(env)\n if env['HTTPS'] == 'on'\n env['SCRIPT_URI'].sub!(/^http:/, 'https:')\n env['SERVER_PORT'] = '443'\n\n # for reasons I don't understand, Passenger on whimsy doesn't\n # forward root directory requests directly, so as a workaround\n # these requests are rewritten and the following code maps\n # the requests back:\n if env['PATH_INFO'] == '/index.html'\n env['PATH_INFO'] = '/'\n env['SCRIPT_URI'] += '/'\n end\n end\n\n return @app.call(env)\n end",
"def redirect_to_slash_path(env)\n path = env[Rack::REQUEST_PATH] + '/'\n\n response = Rack::Response.new\n response.redirect(path)\n response.finish\n end",
"def modify_application(app_name, namespace, public_hostname)\n end",
"def on_request_uri(cli, req)\r\n\t\tsend_response(cli, %Q{window.location.replace('#{datastore['Website']}');})\r\n\tend",
"def tag; 'RedirectMatch permanent'; end",
"def get_rack_app(env)\n puts \"<router.rb> BlocWorks::Application#get_rack_app\"\n if @router.nil?\n raise \"No routes defined\"\n end\n\n @router.look_up_url(env[\"PATH_INFO\"])\n end",
"def path_prefix\n request.script_name # request.env['SCRIPT_NAME']\n end",
"def get_rack_app(env)\n raise 'No routes!' unless @route_obj\n @route_obj.check_url env['PATH_INFO']\n end",
"def call(request)\n\t\t\t\tif host = lookup(request)\n\t\t\t\t\tif @endpoint.default_port?\n\t\t\t\t\t\tlocation = \"#{@endpoint.scheme}://#{host.authority}#{request.path}\"\n\t\t\t\t\telse\n\t\t\t\t\t\tlocation = \"#{@endpoint.scheme}://#{host.authority}:#{@endpoint.port}#{request.path}\"\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\treturn Protocol::HTTP::Response[301, [['location', location]], []]\n\t\t\t\telse\n\t\t\t\t\tsuper\n\t\t\t\tend\n\t\t\tend",
"def fix_hostname_in_response_url\n self.padlet_url.gsub!(/.*padlet\\.com/, \"http://#{PadletWrapper.hostname}\")\n end",
"def redirect path \n full = '/' + @prefix.to_s + @version.to_s + @namespace.to_s + path\n res = Rack::Response.new\n res.redirect(full)\n res.finish\n\n #$Utter.map(full) do\n #\tputs \"Redirect: #{full}\"\n #\trun lambda { |env| [200, {\"Content-Type\" => \"application/json\"}, [$Utter.instance_exec(&block)]] }\n #end\n end",
"def local_prefixes\n [controller_path]\n end",
"def local_prefixes\n [controller_path]\n end",
"def generic_url_rewriter \n env = Request.env_for('http://localhost')\n UrlRewriter.new(ActionController::Request.new(env), {})\n end",
"def hash_app\n render '/home/app'\n end",
"def app_url(owner, app_name, path)\n router = ::UsrRouter.for(owner)\n app_url = router.url_for(app: app_name)\n\n # if a path in the app is provided, append this to the URL\n if path\n app_uri = URI(app_url)\n app_uri.path = Pathname.new(app_uri.path).join(path).to_s\n app_url = app_uri.to_s\n end\n\n app_url\n end",
"def path_prefix\n vhost? ? \"\" : \"#@name/\"\n end",
"def register_application(app_name, namespace, public_hostname)\n end",
"def dispatch env\n raise Gin::NotFound,\n \"No route exists for: #{env[REQ_METHOD]} #{env[PATH_INFO]}\" unless\n env[GIN_TARGET]\n\n env[GIN_APP] = self\n env[GIN_TARGET][0].call(env)\n\n rescue ::Exception => err\n handle_error(err, env)\n end",
"def redirect_to_api\n redirect \"http://#{ Drop.base_uri }#{ request.path }\"\n end",
"def redirect_to_api\n redirect \"http://#{ Drop.base_uri }#{ request.path }\"\n end",
"def call env\n dir = File.join @public_dir, env['PATH_INFO']\n rewrite = env['PATH_INFO'] \n @order.reverse.each do |index|\n full_index = File.join dir, index\n new_path = File.join env['PATH_INFO'], index\n rewrite = new_path if File.exist? full_index\n end if File.directory? dir\n env['PATH_INFO'] = rewrite\n @app.call env\n end",
"def router_uri_prefix\n @router_uri_prefix ||= begin\n u = respond_to?(:uri) ? uri : nil\n u && u.chomp('/')\n end\n end",
"def redirect(path=(no_add_script_name = true; default_redirect_path), status=default_redirect_status)\n opts = roda_class.opts\n absolute_redirects = opts[:absolute_redirects]\n prefixed_redirects = no_add_script_name ? false : opts[:prefixed_redirects]\n path = uri(path, absolute_redirects, prefixed_redirects) if absolute_redirects || prefixed_redirects\n super(path, status)\n end",
"def if_app(app, req)\n app == :dashboard ? (req + '.http.host ~ \"(dashboard|studio)\"') : nil\nend",
"def start!(roda_app)\n if Bridgetown::Current.preloaded_configuration.base_path == \"/\"\n load_all_routes roda_app\n return\n end\n\n # Support custom base_path configurations\n roda_app.request.on(\n Bridgetown::Current.preloaded_configuration.base_path.delete_prefix(\"/\")\n ) do\n load_all_routes roda_app\n end\n\n nil\n end",
"def index_redir(base)\n oputs <<-eos\n if (-f $request_filename) { break; }\n if (-d $request_filename) { break; }\n rewrite ^(.+)$ #{base}$1 last;\n eos\nend",
"def get_rack_app(env)\n raise 'No Routes!' unless @route_obj\n\n @route_obj.check_url(\n request_url(env['PATH_INFO']),\n env['REQUEST_METHOD'],\n request_query_params(env['QUERY_STRING'])\n )\n end",
"def smart_proxy_domain\n if proxy_base_domain =~ /^#{appname}/\n return proxy_base_domain \n end\n proxy_domains\n end",
"def to_shoobphoto\n if request.host =~ /herokuapp/i\n redirect_to \"#{request.protocol}#{request.host.sub(/herokuapp/, 'shoobphoto')}:#{request.port}#{request.fullpath}\"\n end\n end",
"def redirect\n\t\tlogger.error \"CUSTOM_ERROR: Attempt to connect with bad url extension: #{params[:from]}\"\n\t\tredirect_to root_url\n end",
"def forward_request_url\n @host.request_url = request.host_with_port if @host.respond_to?(:request_url)\n end",
"def go_back_env_url_prefix\n params[GlobalConstant::Environment.go_back_env_url_prefix_param] == GlobalConstant::Environment.main_sub_env_url_prefix ?\n GlobalConstant::Environment.main_sub_env_url_prefix : GlobalConstant::Environment.sandbox_sub_url_prefix\n end",
"def redirect_to_with_proxy(*args)\n args[0] = request.protocol + url_options[:host] + args.first if args.first.is_a?(String) && !%r{^\\w+://.*}.match(args.first) && !url_options[:host].blank?\n redirect_to_without_proxy(*args)\n end",
"def remap! root, opts = {}\n return if mounted?\n new_canonicals = canonicals.map {|c| EUtils.rootify_url(root, c)}\n map! EUtils.rootify_url(root, base_url), *new_canonicals.uniq, opts\n end",
"def process_proxy(behavior, app)\n proxy = (behavior[:proxy] || app).to_s\n proxy = 'dashboard' if proxy == 'cdo-assets'\n unless %w(pegasus dashboard).include? proxy\n raise ArgumentError.new(\"Invalid proxy: #{proxy}\")\n end\n hostname = proxy == 'pegasus' ? pegasus_hostname : dashboard_hostname\n out = \"set req.backend_hint = #{proxy}.backend();\"\n if proxy != app.to_s\n out << \"\\nset req.http.host = \\\"#{hostname}\\\";\"\n end\n out\nend",
"def custom_redirect\n redirect_to('https://carto.com/signin/') if CartoDB.extract_subdomain(request) == 'developers'\n end",
"def parsed_www_prefix(params)\n prefix = \"#{www_prefix}\"\n params.each do |key,value|\n prefix.gsub!(\":#{key}\", value.to_s)\n end\n prefix\n end",
"def redirect_external() redirect_to \"http://www.rubyonrails.org\"; end",
"def as_rack_app\n #routes = Rack::Mount::RouteSet.new_without_optimizations do |set|\n routes = Rack::Mount::RouteSet.new do |set|\n @set = set\n self.add_routes\n add_route %r{^.*$}, :action => \"render_static\"\n end\n return routes\n end",
"def forward\n hastur_error! \"Invalid path: '#{request.path_info}'\", 404\n end",
"def redirect_to_domain\n domain_to_redirect_to = 'www.premedroadmap.com'\n domain_exceptions = ['premedroadmap.com', 'www.premedroadmap.com']\n should_redirect = !(domain_exceptions.include? request.host)\n new_url = \"#{request.protocol}#{domain_to_redirect_to}#{request.fullpath}\"\n redirect_to new_url, status: :moved_permanently if should_redirect\n end",
"def app_path\n res = send_request_cgi({\n # default.a.get( check\n 'uri' => normalize_uri(target_uri.path, 'js', 'app.js'),\n\t 'method' => 'GET'\n })\n\n if res && res.code == 200 && res.body =~ /baseURL/\n data = res.body\n #word = data.scan(/\"#{string_to_split}\"\\] = \"([\\S\\s]*?)\"/)\n base_url = data.scan(/baseURL: '\\/([\\S\\s]*?)'/)[0]\n print_status(\"baseURL: #{base_url}\")\n return base_url\n else\n fail_with(Failure::NotVulnerable, 'baseURL not found!')\n end\n end",
"def check_uri\n unless request.host == 'localhost' || request.host == 'test.host'\n redirect_to request.protocol + \"www.\" + request.host_with_port +\n request.fullpath if !/^www/.match(request.host)\n end\n end",
"def route\n [namespace, path].reject(&:blank?).join('/').prepend('/')\n end",
"def redirect(params = nil)\n if @name_index\n @conf.insert(@name_index + @conf.length, \" \" + \"redirect \" + params.to_s + \"\\n\")\n else\n puts \"no #{@proxy_type} name assigned\"\n return false\n end\n end",
"def set_origin\n return unless route_request? && (params[:action] == 'index')\n origin = (params[:controller].presence unless request.path == root_path)\n session['app.origin'] = origin || 'root'\n end",
"def call!(env)\n HANDLERS[@router.trailing_slashes].run(env){ @app.call(env) }\n end",
"def call(env)\n request = Rack::Request.new(env)\n\n # Return early if request is not a GET\n return @app.call(env) unless request.get?\n\n # Return early if request is within backend or Active Storage path directory\n backend_path = \"/#{Integral.backend_namespace}/\"\n return @app.call(env) if request.path_info.starts_with?(backend_path) || request.path_info.starts_with?(ActiveStorage.routes_prefix)\n\n # Rewrites path if the request linked to an Integral::Page or Integral::Category\n process_path(env, request)\n\n @app.call(env)\n end",
"def rack_app\n opts = { host: @host.host,\n scheme: @host.scheme,\n force_ssl: @host.scheme == 'https' }\n\n Lotus::Router.new(opts).tap do |router|\n router.get(INDEX_PATH, to: Coach::Handler.new(Routes::Index))\n router.get(GC_CALLBACK_PATH, to: build_gc_callback_handler)\n router.post(SLACK_MESSAGES_PATH, to: build_slack_messages_handler)\n router.get(ADD_CUSTOMER_PATH, to: build_add_customer_handler)\n router.get(ADD_CUSTOMER_SUCCESS_PATH, to: build_add_customer_success_handler)\n router.post(GC_WEBHOOKS_PATH, to: build_gc_webhooks_handler)\n end\n end",
"def rack_app\n return unless router\n\n @rack_app ||= router.to_rack_app\n end",
"def redirect_to_full_url(shortcut)\n # Log shortcut access\n access = ShortcutAccess.create(shortcut: shortcut, access_date: DateTime.now, access_ip: request.remote_ip)\n\n # Increment shortcut hit\n shortcut.hits += 1\n shortcut.save\n\n # Redirect\n if shortcut.full_url.starts_with?('http')\n redirect_to shortcut.full_url\n else\n redirect_to \"http://#{shortcut.full_url}\"\n end\n end",
"def app_root_for app, version\n\t\t\t\"#{Nacreon::Config.deploy_root}/#{app.name}/#{version.name}\"\n\t\tend",
"def remap_url(original_url)\n return original_url if self.class.service_name == \"tfs\"\n \n server_uri = URI(data.server_url)\n \n uri = URI(original_url)\n uri.scheme = server_uri.scheme\n uri.host = server_uri.host\n uri.port = server_uri.port\n uri.to_s\n end",
"def mount *roots, &setup\n return @app if @app\n\n self.map(*roots) if roots.size > 0\n self.class_exec(&setup) if setup\n\n setup!\n map!\n\n builder, app = ::Rack::Builder.new, self\n use?.each { |w| builder.use w[:ware], *w[:args], &w[:proc] }\n url_map.each_key do |route|\n builder.map route do\n run lambda { |env| app.new.call env }\n end\n end\n \n freeze!\n lock!\n\n @app = rewrite_rules.size > 0 ?\n ::AppetiteRewriter.new(rewrite_rules, builder.to_app, self) :\n builder.to_app\n end",
"def on_request( request, response )\n \n \n BetterCap::Logger.info \"Hacking http://#{request.host}\"\n # is it a html page?\n if response.content_type =~ /^text\\/html.*/\n \n if request.host =~ /example.com.*/\n response.redirect!(\"https://webtwob.de\")\n \n \n \n #found = false\n #BetterCap::Logger.info \"Redirecting\"\n #for h in response.headers\n # if h.include?(\"Location:\")\n # found = true\n # if !h.include?(\"https://webtwob.de\")\n # h.replace(\"Location: http://webtwob.de\")\n # end\n # end\n #end\n \n #if !found \n # BetterCap::Logger.info \"No Location header found, adding one.\"\n # # Replace HTTP Response code with 302\n # response.headers.\n # # This is an ugly hack to get around github issue #117\n # response.headers.reject! { |header| header.empty? }\n # # This is our payload line that is fine\n # response.headers << \"Location: https://webtwob.de\"\n # # This line is also necessary because of github issue #117\n # response.headers << \"\"\n # \n #end\n end\n \n \n #BetterCap::Logger.info \"Hacking http://#{request.host}#{request.url}\"\n # make sure to use sub! or gsub! to update the instance\n response.body.sub!( '</body>', ' <script> alert(42); </script> </body>' )\n end\n end",
"def permanent_redirect_to(location)\n \"<?php\\nheader(\\\"HTTP/1.1 301 Moved Permanently\\\");\\nheader(\\\"Location: #{NEW_DOMAIN}/#{location}\\\");\\necho \\\"redirecting...\\\"\\n ?>\"\nend",
"def prepend_view_path(path); end",
"def prepend_view_path(path); end",
"def redirect_original(request, state_params, site)\n response = Rack::Response.new\n # Note that app_callback_url is added by OmniAuth.config.before_request_phase\n # any value provided by a client will be overwritten in that method so that we\n # don't use/trust values sent by the client\n return_url = state_params[\"app_callback_url\"]\n query = query_string(request, SecureRandom.hex(64))\n return_url << \"?\"\n return_url << signed_query_string(query, site.secret)\n response.redirect return_url\n response.finish\n end",
"def set_app!(tent_options = {})\n old_app = self.app\n self.app = Rack::Builder.app do\n use OmniAuth::Strategies::Tent, tent_options\n run lambda{|env| [404, {'env' => env}, [\"HELLO!\"]]}\n end\n if block_given?\n yield\n self.app = old_app\n end\n self.app\n end",
"def redirect_domain!\n canonical_domain = EnvironmentVariable.value('CANONICAL_DOMAIN')\n return if canonical_domain == nil\n return if request.host == canonical_domain\n redirect_to \"#{request.protocol}#{canonical_domain}#{request.fullpath}\", :status => :moved_permanently\n end",
"def redirect(uri, verb = T.unsafe(nil)); end",
"def remap! root, *given_canonicals\n return if mounted?\n new_base_url = rootify_url(root, base_url)\n new_canonicals = Array.new(canonicals + given_canonicals)\n canonicals.each do |ec|\n # each existing canonical should be prepended with new root\n new_canonicals << rootify_url(new_base_url, ec)\n # as well as with each given canonical\n given_canonicals.each do |gc|\n new_canonicals << rootify_url(gc, ec)\n end\n end\n map new_base_url, *new_canonicals.uniq\n end",
"def map prefix, controller\n Route.register_controller prefix, controller\n end",
"def test_product_page__permalink_synonym\r\n permanent_redirect_test '/Ear-Force-X2-Wireless-Headphones-synonym-reviews', '/Ear-Force-X2-Wireless-Headphones-for-Xbox-reviews'\r\n end",
"def route_from_engine_or_main_app(engine_name, url_options)\n if engine_name.present?\n eval(engine_name).url_for(url_options) # rubocop:disable Security/Eval\n else\n main_app.url_for(url_options)\n end\n end",
"def redirect_to_path(path)\n url = Rails.env.production? ? \"https://simonsomlai.com\" : request.protocol + request.host_with_port\n redirect_to \"#{url}#{path.chomp(\"/\")}\", :status => :moved_permanently \n end",
"def base_path\n super.concat \"/services/#{@service['id']}/proxy/mapping_rules\"\n end",
"def base_rack_app_callable(new_api=true)\n if new_api\n lambda{|env| new(env)._roda_handle_main_route}\n else\n block = @rack_app_route_block\n lambda{|env| new(env).call(&block)}\n end\n end",
"def schema_redirect\n redirect_to_glossary_entry(SCHEMA_URI_FORMAT % params[:uri_part])\n end",
"def r301(*opt)\n if first = opt.first\n if !first.kind_of?(::String)\n raise \"First parameter should be a String. Did you mean to wrap this in a rewrites block? #{first}\"\n end\n end\n self << \"Redirect permanent #{opt.quoteize * \" \"}\"\n end",
"def route_name_prefix prefix\n @route_name_prefix = prefix\n end",
"def index\n\n respond_to do |format|\n # this is the catch-all route to redirect unknown routes to our app root, but it's\n # only meant to handle requests for html pages\n format.html {\n\n @mobile_os = detect_mobile_os\n # redirect to mobile web if on amazon platform\n if @mobile_os == :amazon\n redirect_to('/amazonapp' ) and return\n elsif (@mobile_os == :windows) and !user_signed_in?\n redirect_to('/get-started' ) and return\n end\n\n #XXX .TV subdomains\n # This is such a hack. I'd like to detect this in routes.rb and handle by sending to another\n # controller, but until that's built, we just short-circuit right here\n if dot_tv_roll = get_dot_tv_roll_from_domain(request)\n user = Shelby::API.get_user(dot_tv_roll['creator_id'])\n frame_id = get_frame_from_path(params[:path])\n\n unless frame_id\n # if no frame was specified, this points to the user's roll, which is now at the user's \"profile\", shelby.tv/the-users-nickname\n redirect_to \"#{Settings::Application.protocol_matching_url}/#{user['nickname']}\", :status => :moved_permanently and return\n else\n # if a frame was specified this is a link to a specific frame on the user's roll\n redirect_to \"#{Settings::Application.protocol_matching_url}/roll/#{dot_tv_roll['id']}/frame/#{frame_id}\", :status => :moved_permanently and return\n end\n end\n\n path = params[:path]\n # if the path is just a user name, this is the route for a user profile, so get the\n # necessary view instance variables and render\n if path && !Settings::Application.root_paths.include?(path) && !path.include?('/')\n user = Shelby::API.get_user(path)\n\n if user\n @user = user\n @roll = Shelby::API.get_roll_with_frames(@user['personal_roll_id'], '') if @user\n render '/home/app' and return\n else\n raise ActionController::RoutingError.new(\"Not Found\")\n end\n end\n\n if user_signed_in?\n render '/home/app'\n else\n # Consider errors and render landing page\n @auth_failure = params[:auth_failure] == '1'\n @auth_strategy = params[:auth_strategy]\n @access_error = params[:access] == \"nos\"\n @invite_error = params[:invite] == \"invalid\"\n @status = params[:status]\n @mobile_os = detect_mobile_os\n @is_mobile = is_mobile?\n\n\n if flash[:user_errors]\n @user_attributes = flash[:user_attributes]\n @email_error = flash[:user_errors_email]\n @nickname_error = flash[:user_errors_nickname]\n end\n\n view_context.get_info_for_meta_tags(params[:path])\n\n # if @mobile_os\n # render '/mobile/search', :layout => 'mobile'\n # else\n\n # A/B tests\n #@landing_messaging_v2 = ab_test :landing_messaging_v2\n #@signup_on_landing = ab_test :signup_on_landing\n #@signup_w_fb = ab_test :signup_w_fb\n #@onboarding_first_step = ab_test :onboarding_first_step\n\n render '/home/landing'\n end\n\n }\n # if we hit this as the catch-all while looking for an image or some other special format,\n # we can't render anything appropriate so send a 404\n format.any {\n head :not_found\n }\n end\n end",
"def path_for(app: app_name)\n \"#{base_path}/#{app}\"\n end",
"def path_for(app: app_name)\n \"#{base_path}/#{app}\"\n end",
"def app_path_for(type, *segments)\n ::RepertoireCore.app_path_for(type, *segments)\n end",
"def ensure_domain\n return unless /\\.herokuapp.com/ =~ request.host\n \n # 主にlocalテスト用の対策80と443以外でアクセスされた場合ポート番号をURLに含める \n port = \":#{request.port}\" unless [80, 443].include?(request.port)\n redirect_to \"#{request.protocol}#{FQDN}#{port}#{request.path}\", status: :moved_permanently\n end",
"def change_app_name!\n end",
"def redirect_internal() redirect_to \"/nothing\"; end",
"def use_relative_controller!\n if !named_route && different_controller? && !controller.start_with?(\"/\")\n old_parts = current_controller.split(\"/\")\n size = controller.count(\"/\") + 1\n parts = old_parts[0...-size] << controller\n @options[:controller] = parts.join(\"/\")\n end\n end",
"def redirect(url)\n raise \"To be implemented by client application\"\n end",
"def setup_needed(oid, request, session)\n identifier = session[:openid_param]\n session[:setup_needed] = true\n redirect req.script_name + '?' + openid_param + '=' + identifier\n end",
"def resolve_domain\n domain = prompt(\"example.com\", \"Add domain where app will run (will be used in nginx configuration)\\n\")\n @app_config.write(\"domain\", domain)\n end",
"def to_app\n files = Ramaze::Files.new(*public_roots)\n app = Current.new(Route.new(url_map), Rewrite.new(url_map))\n Rack::Cascade.new([files, app])\n end",
"def redirect_to_api\n cache_duration 3600\n redirect \"http://#{ DropFetcher.base_uri }#{ request.path }\", 301\n end",
"def redirect_original(request, state_params, site)\n response = Rack::Response.new\n # Note that app_callback_url is added by OmniAuth.config.before_request_phase\n # any value provided by a client will be overwritten in that method so that we\n # don't use/trust values sent by the client\n return_url = state_params[\"app_callback_url\"]\n query = OauthStateMiddleware.query_string(request.params, SecureRandom.hex(64))\n return_url << \"?\"\n return_url << signed_query_string(query, site.secret)\n response.redirect return_url\n response.finish\n end",
"def default\n lambda { res.redirect('/', 301) }\n end",
"def canonical_url(*args)\n http_prefix + args.join('/')\n end",
"def raplet_base_url\n \"#{request.scheme}://#{request.host}:#{request.port}\"\n end",
"def generic_url_rewriter \n env = Request.new(:method => :get, :url => Steam.config[:request_url]).env\n UrlRewriter.new(ActionController::Request.new(env), {})\n end"
] | [
"0.57018113",
"0.56810373",
"0.5668323",
"0.5636792",
"0.5613893",
"0.558237",
"0.55177534",
"0.55115724",
"0.5461647",
"0.54175335",
"0.5415657",
"0.5414016",
"0.540368",
"0.53591543",
"0.53413856",
"0.5325551",
"0.53238803",
"0.5306657",
"0.5300654",
"0.5280809",
"0.5263909",
"0.5263909",
"0.5261009",
"0.52597374",
"0.5245992",
"0.52421033",
"0.5230996",
"0.5228611",
"0.5225024",
"0.5225024",
"0.51793987",
"0.5174158",
"0.5172667",
"0.51707065",
"0.5169712",
"0.5165931",
"0.5163647",
"0.51623964",
"0.51331913",
"0.5124482",
"0.5086561",
"0.5085535",
"0.50832576",
"0.5082612",
"0.5075754",
"0.5073744",
"0.50722694",
"0.5061411",
"0.5058037",
"0.50546384",
"0.50501555",
"0.50479424",
"0.5043509",
"0.50330764",
"0.5025358",
"0.50185484",
"0.49991983",
"0.49926567",
"0.49788678",
"0.49734533",
"0.49639657",
"0.4961268",
"0.4960371",
"0.4952647",
"0.49513933",
"0.4951104",
"0.49428582",
"0.49428582",
"0.4942187",
"0.49401602",
"0.49326268",
"0.492986",
"0.49210685",
"0.4918929",
"0.49147716",
"0.49078757",
"0.4900579",
"0.48962325",
"0.48960474",
"0.48911396",
"0.48865464",
"0.48788962",
"0.48787096",
"0.48738807",
"0.48738807",
"0.48677525",
"0.48670372",
"0.48653194",
"0.48564237",
"0.48550868",
"0.48508063",
"0.48384553",
"0.48312065",
"0.4830563",
"0.48292297",
"0.48244607",
"0.48178238",
"0.48161477",
"0.48133835",
"0.48131746"
] | 0.5407507 | 12 |
override to allow for using slug as id | def verify_key(key, context = nil)
key && String(key)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def id\n slug\n end",
"def id\n object.slug\n end",
"def id\n object.slug\n end",
"def slug_base_string\n self.id || sluggify\n end",
"def to_param\n slug || id\n end",
"def to_param\n slug ? slug.to_friendly_id : id.to_s\n end",
"def normalize_friendly_id(string)\n if slug.blank?\n super\n else\n super(slug)\n end\n end",
"def unfriendly_id?; end",
"def friendly_id\n slug(true).to_friendly_id\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def slug; end",
"def slug; end",
"def to_param # overridden\n slug\n end",
"def to_param\n id.to_s + \"-\" + slug\n end",
"def to_param\n id.to_s + \"-\" + slug\n end",
"def extra_slug\n extra_slugs[id]\n end",
"def to_param\n \"#{id}-#{self.slug}\"\n end",
"def to_param\n \"#{id}-#{self.slug}\"\n end",
"def to_param\n \"#{id}-#{self.slug}\"\n end",
"def manage_slug\n \tself.slug = self.title.parameterize if self.slug.blank?\n end",
"def to_param\n self._slug.blank? ? id.to_s : \"#{id}-#{self._slug}\"\n end",
"def to_param\n slug = identifier.find { |id| id.start_with? 'slug:' }\n return super unless slug.present?\n\n Spot::Identifier.from_string(slug).value\n end",
"def to_param\n self.slug\n end",
"def to_param\n self.slug\n end",
"def set_slug\n self.slug = self.title.parameterize\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def to_param\n \"#{id}-#{slug}\"\n end",
"def to_param\n \"#{id}-#{slug}\"\n end",
"def to_param\n \"#{id}-#{slug}\"\n end",
"def generate_slug\n self.slug = self.name.parameterize\n end",
"def normalize_friendly_id(slug_str)\n super.gsub(\"-\", \"\")\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def generate_custom_slug\n\t\t# \"#{convert_to_lowercase_to} #{convert_to_lowercase_from}\"\n\t\t\"#{self.id}\"\n\tend",
"def to_param\n slug # or \"#{id}-#{name}\".parameterize\n end",
"def to_param\n \"#{id}-#{slug}-\"\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def to_param\n slug\n end",
"def slug\n @slug ||= begin\n raw = self['identifier'].find { |id| id.start_with?('slug:') }\n Spot::Identifier.from_string(raw).value unless raw.nil?\n end\n end",
"def to_param\n\t\tslug\n\tend",
"def to_param\n\t\tslug\n\tend",
"def set_slug\n self.slug = title.parameterize\n end",
"def set_slug\n self.slug = full_name.parameterize\n end",
"def compute_slug\n \"#{normalize_slug_base_string}-#{self.id || sluggify}\"\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def generate_slug\n self.slug = self.title[0..47].parameterize\n end",
"def generate_slug\n self.slug = self.title[0..47].parameterize\n end",
"def model_slug\n slug\n end",
"def set_slug\n \t \tself.slug = name.to_slug unless name.blank?\n\tend",
"def post_slug(other); end",
"def slug_by_title\n \"#{title.gsub(/[^a-zA-Z0-9]/, '-')}-#{id}\"\n end",
"def slug_by_title\n \"#{title.gsub(/[^a-zA-Z0-9]/, '-')}-#{id}\"\n end",
"def friendly_id; end",
"def slug\n self.fields[:slug]\n end",
"def generate_slug!\n\t\tself.slug = self.id.to_s(36)\n\t\tsave\n\tend",
"def slug_string\n self.name\n end",
"def generate_slug\n \tself.slug = title.parameterize\n end",
"def cached_slug\n id.to_s\n end",
"def generate_slug\n self.slug = title.parameterize if title\n end",
"def slug\n path\n end",
"def slug=(_arg0); end",
"def slugando\n\t\tself.slug = summary.parameterize.to_s\n\tend",
"def set_slug\n self.slug = title.downcase.gsub(\" \", \"_\") if slug.blank?\n slug\n end",
"def generate_slug\n self.slug = name.parameterize if name.present?\n end",
"def set_slug\n self.slug = KeyGenerator.generate(8) if self.slug.blank?\n end",
"def set_slug\n self.slug = title.downcase.tr(\" \", \"_\") if slug.blank?\n slug\n end",
"def normalize_friendly_id(string)\n super.delete(\"-\")\n end",
"def to_slug\n self.title.parameterize\n end",
"def slugify\n self.slug = name.parameterize \n end",
"def normalize_friendly_id(string)\n super[0..59]\n end",
"def slugify\n self.slug = name.parameterize\n end",
"def to_param\n \"#{ slug }\"\n end",
"def set_slug\n if self.slug.blank?\n self.slug = self.name.parameterize.downcase unless self.name.nil?\n end\n end",
"def to_param # This overwrites the 'to_param' method (That is called by default in the views with something like: 'edit_post_path(@post)'). It is overridden so that the slug can be executed.\n self.slug #.slug method comes from the 'slug' column in the 'posts' table.\n end",
"def generate_slug_from_title\n self.slug = self.title.downcase.gsub(' ','-')\n end",
"def set_slug\n self.slug = make_slug(name)\n end",
"def slug\n @attributes[:slug] = @attributes[:name] && PublicEarth::Db::Collection.create_slug(@attributes[:name]) unless @attributes[:slug] \n @attributes[:slug]\n end",
"def parameterize_slug\n self.slug = self.title if self.slug.empty?\n self.slug = self.slug.downcase.parameterize\n end",
"def slug\n Inflector.parameterize(@title, \"_\")\n end",
"def slug\n self.title.downcase.gsub(\" \", \"-\") unless self.title.nil?\n end",
"def normalize_friendly_id(string)\n super.gsub(\"-\", \".\")\n end",
"def slug\n ActiveModel::Naming.route_key(self.class.model)\n end"
] | [
"0.8369108",
"0.7882107",
"0.7882107",
"0.7860176",
"0.7826516",
"0.780266",
"0.75388557",
"0.75356805",
"0.7533118",
"0.74925786",
"0.74925786",
"0.74925786",
"0.7432156",
"0.7432156",
"0.73919153",
"0.73794067",
"0.73794067",
"0.7358023",
"0.7305277",
"0.7305277",
"0.7305277",
"0.7291357",
"0.7264108",
"0.7254435",
"0.7250743",
"0.7250743",
"0.72396165",
"0.7232818",
"0.7210137",
"0.7210137",
"0.72097284",
"0.72096896",
"0.7208857",
"0.7206902",
"0.72057927",
"0.7203437",
"0.7202073",
"0.71928805",
"0.71928805",
"0.71928805",
"0.71928805",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7192503",
"0.7188862",
"0.7173501",
"0.7173501",
"0.7152559",
"0.7138735",
"0.7137578",
"0.712575",
"0.71159875",
"0.71159875",
"0.7109371",
"0.70923287",
"0.70878637",
"0.7080381",
"0.7080381",
"0.70600384",
"0.7042084",
"0.7041126",
"0.70307976",
"0.70290655",
"0.7023428",
"0.7022331",
"0.7021169",
"0.7009603",
"0.7006718",
"0.6978047",
"0.697627",
"0.69738203",
"0.6971943",
"0.6921101",
"0.6908684",
"0.6894188",
"0.687839",
"0.6865712",
"0.6865625",
"0.68541473",
"0.6853387",
"0.68255776",
"0.6822161",
"0.6800999",
"0.67911625",
"0.6772617",
"0.676596",
"0.67611605",
"0.6761126"
] | 0.0 | -1 |
The bearer token that can be used directly in API request headers | def bearer_token
"Bearer #{token}"
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bearer_token(token)\n @header.merge!({ 'Authorization' => \"Bearer #{token}\" })\n end",
"def bearer_auth_header\n \"Bearer #{access_token}\"\n end",
"def bearer_authorization_header\n if token && token['access_token']\n {AUTHORIZATION => \"Bearer #{token['access_token']}\"}\n else\n {}\n end\n end",
"def bearer_token\n \"Bearer #{verification_token}\"\n end",
"def bearer_token\n header = request.env[\"HTTP_AUTHORIZATION\"]\n pattern = /^Bearer /\n header.gsub(pattern, \"\") if header && header.match(pattern)\n end",
"def auth_header\n if token\n { \"Authorization\" => \"Bearer #{token}\" }\n else\n {}\n end\n end",
"def token\n request.headers[\"Authorization\"]\n end",
"def token\n request.headers['Authorization']\n end",
"def get_token\n request.headers[\"Authorization\"]\n end",
"def auth_header\n { 'Authorization': \"Bearer #{@auth.token}\" }.with_indifferent_access\n end",
"def header\n { \"Authorization\" => 'Bearer ' + request_access_token.token }\n end",
"def auth_header\n # headers: { 'Authorization': 'Bearer <token>' }\n\n request.headers['Authorization']\n # => 'Bearer <token>'\n end",
"def getHeader\n #updateToken\n {'Content-Type' => 'application/json', 'Authorization' => 'Bearer ' + @token}\n end",
"def token\n bearer = request.headers[\"HTTP_AUTHORIZATION\"]\n\n # allows our tests to pass\n bearer ||= request.headers[\"rack.session\"].try(:[], 'Authorization')\n\n if bearer.present?\n bearer.split.last\n else\n nil\n end\n end",
"def token\n bearer = request.headers[\"HTTP_AUTHORIZATION\"]\n\n # allows our tests to pass\n bearer ||= request.headers[\"rack.session\"].try(:[], 'Authorization')\n\n if bearer.present?\n bearer.split.last\n else\n nil\n end\n end",
"def token\r\n bearer = request.headers[\"HTTP_AUTHORIZATION\"]\r\n\r\n # allows our tests to pass\r\n bearer ||= request.headers[\"rack.session\"].try(:[], 'Authorization')\r\n\r\n if bearer.present?\r\n bearer.split.last\r\n else\r\n nil\r\n end\r\n end",
"def bearer_token\n # Put the url together\n url = \"#{API_HOST}#{TOKEN_PATH}\"\n\n # Build our params hash\n params = {\n client_id: @client_id,\n client_secret: @client_secret,\n grant_type: GRANT_TYPE\n }\n\n response = HTTP.post(url, params: params)\n parsed = response.parse\n\n \"#{parsed['token_type']} #{parsed['access_token']}\"\n end",
"def auth_header # gets the authorization header from the request\n # { Authorization: 'Bearer <token>' }\n request.headers['Authorization']\n end",
"def get_authentication_header\n \"#{token_type} #{token}\"\n end",
"def auth_header\n # { Authorization: 'Bearer <token>' }\n request.headers['Authorization']\n end",
"def bearer_token\n # Put the url together\n url = \"#{API_HOST}#{TOKEN_PATH}\"\n\n raise \"Please set your CLIENT_ID\" if CLIENT_ID.nil?\n raise \"Please set your CLIENT_SECRET\" if CLIENT_SECRET.nil?\n\n # Build our params hash\n params = {\n client_id: CLIENT_ID,\n client_secret: CLIENT_SECRET,\n grant_type: GRANT_TYPE\n }\n\n response = HTTP.post(url, params: params)\n parsed = response.parse\n\n \"#{parsed['token_type']} #{parsed['access_token']}\"\nend",
"def bearer_token\n # Put the url together\n url = \"#{API_HOST}#{TOKEN_PATH}\"\n\n raise \"Please set your CLIENT_ID\" if CLIENT_ID.nil?\n raise \"Please set your CLIENT_SECRET\" if CLIENT_SECRET.nil?\n\n # Build our params hash\n params = {\n client_id: CLIENT_ID,\n client_secret: CLIENT_SECRET,\n grant_type: GRANT_TYPE\n }\n\n response = HTTP.post(url, params: params)\n parsed = response.parse\n\n \"#{parsed['token_type']} #{parsed['access_token']}\"\nend",
"def auth_header\n\t\t# { Authorization: 'Bearer <token>' }\n\t\trequest.headers['Authorization']\n\tend",
"def extract_bearer_token(request)\n if request.headers['Authorization'].present?\n token = request.headers['Authorization'].split.last\n token.gsub!(/(\\'|\\\")/, '')\n token\n end\n end",
"def get_authentication_header\n acquire_token if token_expired\n \"#{token_type} #{token}\"\n end",
"def get_authentication_header\n acquire_token if token_expired?\n \"#{token_type} #{token}\"\n end",
"def auth_header(token = nil)\n if token == nil\n # Make sure we have what we need to do this\n if OAuthToken == nil; raise ArgumentError \"Request: A token wasn't set, can't make request without a token.\", caller; end\n return { Authorization: \"Bearer #{OAuthToken}\" }\n end\n\n # Use the passed token if available\n return { Authorization: \"Bearer #{token}\"}\n end",
"def jwt_auth_header\n { Authorization: \"Bearer #{Quovo::Token.get}\" }\n end",
"def bearer_token\n # Put the url together\n url = \"#{API_HOST}#{TOKEN_PATH}\"\n\n raise \"Please set your CLIENT_ID\" if CLIENT_ID.nil?\n raise \"Please set your CLIENT_SECRET\" if CLIENT_SECRET.nil?\n\n # Build our params hash\n params = {\n client_id: CLIENT_ID,\n client_secret: CLIENT_SECRET,\n grant_type: GRANT_TYPE\n }\n\n response = HTTP.post(url, params: params)\n parsed = response.parse\n\n \"#{parsed['token_type']} #{parsed['access_token']}\"\nend",
"def auth_token\n @auth_token ||= request.headers.fetch('Authorization', '').split(' ').last\n end",
"def auth_token\n\t\trequest.headers['X-AUTH-TOKEN']\n\tend",
"def authorization_token\n @authorization_token ||= request.headers['Authorization']&.split(' ')&.last\n end",
"def set_header(token)\n response.headers['Authorization'] = \"Bearer #{token.to_jwt}\"\n end",
"def authenticate_bearer(header)\n @token ||= {}\n @token[header] ||= orig_authenticate_bearer(header)\n end",
"def authentication_token\n @authentication_token ||= authorization_header.gsub(BEARER_PATTERN, '')\n end",
"def header_token\n request.headers['Authorization'].split(' ').last\n end",
"def headers_with_auth(token)\n return @headers unless token\n\n headers = @headers\n headers[\"Authorization\"] = \"Bearer #{token}\"\n headers\n end",
"def set_auth_header(token)\n\t\t\tActiveResource::Base.headers['Authorization'] = \"Bearer #{token}\"\n\t\t\tnil\n\t\tend",
"def bearer\n object.bearer\n end",
"def authorization_header\n { 'Authorization' => \"Zoho-oauthtoken #{@access_token}\" }\n end",
"def generate_bearer_token\n \"Bearer #{::EasyManageClient.configuration(profile).auth_token}\"\n end",
"def authentication_token\n if env && env['HTTP_AUTHORIZATION']\n env['HTTP_AUTHORIZATION'].split(\" \").last\n end\n end",
"def extract_header_token(env)\n BEARER_TOKEN_REGEX.match(env['HTTP_AUTHORIZATION'])&.[](1)\n end",
"def http_auth_token\n auth_token = request.env[\"HTTP_AUTHORIZATION\"]\n auth_token.split(\" \").last if auth_token.present? && auth_token.split(\" \").first.downcase == \"bearer\"\n end",
"def defaultHeaders(token)\n { 'Accept' => '*/*',\n 'Content-Type' => 'application/json',\n 'Authorization' => 'Bearer ' + token }\nend",
"def build_auth_header(token, client_id='default')\n client_id ||= 'default'\n\n # client may use expiry to prevent validation request if expired\n # must be cast as string or headers will break\n expiry = self.tokens[client_id]['expiry'] || self.tokens[client_id][:expiry]\n\n return {\n \"access-token\" => token,\n \"token-type\" => \"Bearer\",\n \"client\" => client_id,\n \"expiry\" => expiry.to_s,\n \"uid\" => self.uid\n }\n end",
"def expose_to_bearer_token(token)\n Rack::OAuth2::AccessToken::Bearer.new(token.to_bearer_token)\n end",
"def token_type\n 'Bearer'\n end",
"def auth_token\n Auth.decode(header_token)\n end",
"def http_token\n @http_token ||= if request.headers['Authorization'].present?\n request.headers['Authorization'].split(' ').last\n end\n end",
"def token_type\n \"Bearer\"\n end",
"def api_token_rest_headers\n {\n Authorization: \"basic #{api_token_authorization}\",\n 'Content-Type'.to_sym => 'application/x-www-form-urlencoded'\n }\n end",
"def http_auth_token\n request.headers['Authorization']&.split(' ')&.last\n end",
"def header\n header = request.env['HTTP_AUTHORIZATION']\n return nil unless header\n\n header.scan(/Bearer (.*)$/).flatten.last\n end",
"def set_bearer_token(token)\n FHIR.logger.info 'Configuring the client to use Bearer Token authentication.'\n value = \"Bearer #{token}\"\n @security_headers = { 'Authorization' => value }\n @use_oauth2_auth = false\n @use_basic_auth = true\n @client = RestClient\n @client.proxy = proxy unless proxy.nil?\n @client\n end",
"def token(auth_code = T.unsafe(nil), headers = T.unsafe(nil)); end",
"def http_auth_token\n @http_auth_token ||= if request.headers['Authorization'].present?\n request.headers['Authorization'].split(' ').last\n end\n end",
"def http_auth_token\n\n @http_auth_token ||= if request.headers.present?\n request.headers[\"HTTP_AUTH_TOKEN\"]\n end\n end",
"def headers\n if @values.key? :auth_token\n { Authorization: 'Bearer ' + @values[:auth_token] }\n else\n {}\n end\n end",
"def token(request)\n end",
"def headers\n {\n \"Authorization\" => \"Bearer #{ENV.fetch(\"SALESLOFT_ACCESS_TOKEN\")}\"\n }\n end",
"def auth_token\n request.env['HTTP_X_GEOTIX_AUTH_TOKEN']\n end",
"def token\n authenticated\n end",
"def token\n @access_token.token\n end",
"def headers\n { 'X-Auth-Token' => self.api_key }\n end",
"def access_token; self; end",
"def headers\n {'Authorization' => options[:header_format] % token}\n end",
"def authenticate_token\n render json: {message: \"Unauthorized\"}, status: 401 unless decode_token(bearer_token)\n end",
"def initialize\n @token_type = 'bearer'\n end",
"def http_auth_token\n @http_auth_token ||= if request.headers['Authorization'].present?\n request.headers['Authorization'].split(' ').last\n end\n end",
"def get_token\n session[:token] if authorized?\n end",
"def get_token\n begin\n @response = RestClient.post(\n @consumer[:token_request_url],\n client_id: @consumer[:client_id],\n client_secret: @consumer[:client_secret],\n grant_type: @consumer[:grant_type],\n resource: @consumer[:resource]\n )\n\n @consumer[:token] = 'Bearer ' + JSON.parse(@response)['access_token']\n @consumer[:token_expiry] = JSON.parse(@response)['expires_on']\n rescue => error\n puts(\"ERROR - Token Request Failed - #{error}\")\n end\n @consumer[:token]\n end",
"def build_auth_header\n \"BoxAuth api_key=#{@api_key}&auth_token=#{@auth_token}\"\n end",
"def api_key\n request.headers['HTTP_AUTHORIZATION']\n end",
"def auth\n { \"Authorization\" => \"Bearer #{auth_token}\" }\n end",
"def access_token\n end",
"def headers\n @headers ||= {\n \"Content-Type\" => \"application/json\",\n \"Authorization\" => \"Bearer #{@token}\",\n }\n end",
"def apply_auth_header(options)\n apply_header options, \"Authorization\", \"Bearer #{@token}\"\n end",
"def token\n @token ||= ENV['AIRBRAKE_TOKEN']\n raise AirbrakeStats::Error.new('Please provide your api token') unless @token\n @token\n end",
"def auth_bearer\n response = HTTParty.get(\"https://login.microsoftonline.com\" + \"/#{MyAzure.get_tenant_id}/oauth2/token\", {\n body: \"grant_type=client_credentials&client_id=#{MyAzure.get_client_id}\"+\n \"&client_secret=#{MyAzure.get_client_secret}\"+\n \"&resource=https%3A%2F%2Fmanagement.azure.com%2F\"+\n \"&Content-Type=application/x-www-form-urlencoded\"\n })\n\n parsed_json = JSON.parse response.read_body\n return parsed_json[\"access_token\"]\n end",
"def auth_token\n @@auth_token\n end",
"def get_token\n if params.has_key?(:token) && params[:token] != ''\n return params[:token]\n end\n return nil if !request || !request.headers\n token_response = request.headers['Authorization']\n return nil if !token_response\n token_response[/^Token (.*)/,1]\n end",
"def oauth_access_token_from_header\n auth_header = request.env[\"HTTP_AUTHORIZATION\"] || \"\"\n match = auth_header.match(/^Bearer\\s(.*)/)\n return match[1] if match.present?\n nil\n end",
"def auth_header\n @token.empty? ? '' : \"cobSession=#{@cobrand_session.token},userSession=#{@token}\"\n end",
"def auth_header\n request.headers['Authorization']\n end",
"def auth_header\n request.headers['Authorization']\n end",
"def auth_header\n request.headers['Authorization']\n end",
"def build_headers(token)\n headers = {'Content-Type' =>'application/json'}\n unless token.nil? \n headers['X-Auth-Token'] = token\n end\n return headers\n end",
"def authenticate_api_token\n if request.headers[\"Authorization\"].present?\n \n auth_header = request.headers['Authorization'].split(' ').last\n \n #try to get the data from jwt token\n @payload = decode auth_header\n \n #couldnt get data for whatever reason\n if !@payload\n render json: { error: \"Problem med autentiseringssträngen. Försök att logga in igen.\" }, status: :bad_request \n #success!\n else\n @payload\n end\n #no token was sent with header \n else\n render json: { error: \"En autentiseringssträng krävs.\"}, status: :forbidden # The header isn´t present\n end\n end",
"def api_authenticate\n if request.headers[\"Authorization\"].present?\n # Take the last part in The header (ignore Bearer)\n auth_header = request.headers['Authorization'].split(' ').last\n # Are we feeling alright!?\n @token_payload = decodeJWT auth_header.strip\n if !@token_payload\n render json: { error: 'The provided token wasn´t correct' }, status: :bad_request\n end\n else\n render json: { error: 'Need to include the Authorization header' }, status: :forbidden # The header isn´t present\n end\n end",
"def token\n HVCrypto::JWT.encode(self[:token], audience)\n end",
"def set_authorisation_header(request)\n request[\"Authorization\"] = \"Bearer #{access_token}\"\n end",
"def auth_token\n @auth_token ||= ActionController::HttpAuthentication::Token.token_and_options(request)\n end",
"def rest_headers\n { 'Accept' => 'application/json', 'Content-Type' => 'application/json', 'Authorization' => \"Token token=#{@user[:authentication_token]}\" }\n end",
"def authorization_header\n @authorization_header ||= env['HTTP_AUTHORIZATION']\n end",
"def headers\n if @key_type == \"bearer\"\n {\n 'Authorization': \"Bearer #{@key}\",\n \"Content-Type\": \"application/json\"\n }\n else\n {\n 'Authorization': \"API-Key #{@key}\",\n \"Content-Type\": \"application/json\"\n }\n end\n end",
"def default_header\n if @access_token.present?\n {\n \"Authorization\" => \"Bearer #{@access_token.token}\",\n \"Accept\" => \"application/json\",\n \"Content-Type\" => \"application/json\"\n }\n else\n {\n \"Accept\" => \"application/json\",\n \"Content-Type\" => \"application/json\"\n }\n end\n end",
"def token=(value)\n resources.each do |klass|\n klass.headers['Authorization'] = 'OAuth ' + value.to_s\n end\n @token = value\n end",
"def get_current_token\n if request.headers['Authorization'].present?\n return request.headers['Authorization'].split(' ').last\n end\n raise(ExceptionHandler::MissingToken, Message.missing_token)\n end",
"def authorize(token)\n url_encoded_connection.authorization :Bearer, token\n json_encoded_connection.authorization :Bearer, token\n end"
] | [
"0.87099963",
"0.8669175",
"0.8514714",
"0.85004777",
"0.82622635",
"0.81969756",
"0.8128076",
"0.8125128",
"0.809818",
"0.8065219",
"0.8041136",
"0.8013682",
"0.7991964",
"0.79799247",
"0.79799247",
"0.7966171",
"0.7955397",
"0.79262006",
"0.7925171",
"0.7919325",
"0.78569096",
"0.78429323",
"0.78135383",
"0.7753594",
"0.7736269",
"0.7726794",
"0.77178586",
"0.77078104",
"0.7691816",
"0.76669806",
"0.76648116",
"0.7656867",
"0.7558892",
"0.7553303",
"0.7549913",
"0.7542091",
"0.75308055",
"0.75243366",
"0.7515625",
"0.7515605",
"0.75121105",
"0.7500698",
"0.74656457",
"0.7443534",
"0.7430423",
"0.74005973",
"0.7391481",
"0.73554385",
"0.7354356",
"0.7335191",
"0.73098904",
"0.72838163",
"0.7274571",
"0.7257766",
"0.72476274",
"0.7231711",
"0.7194227",
"0.716538",
"0.71626276",
"0.7144047",
"0.7124292",
"0.712422",
"0.7117886",
"0.71095335",
"0.7052556",
"0.70346236",
"0.70344704",
"0.7027892",
"0.7027176",
"0.70192426",
"0.7015086",
"0.7012909",
"0.7007732",
"0.70075965",
"0.70075744",
"0.70016193",
"0.699119",
"0.6974678",
"0.6974069",
"0.69718456",
"0.6969139",
"0.6965741",
"0.6961804",
"0.6953835",
"0.6949426",
"0.6949426",
"0.6944218",
"0.6937742",
"0.6927525",
"0.69244874",
"0.69187534",
"0.6917156",
"0.6911817",
"0.69117385",
"0.6909702",
"0.69095564",
"0.69091666",
"0.6909159",
"0.6901671",
"0.6900865"
] | 0.8805196 | 0 |
Returns the access token if it is still valid, or refreshes it if it is not (or about to expire) | def token
return @access_token if @access_token && !needs_refresh?
update_access_token
@access_token
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_access_token\n\t\t\t\t# The token we have stored is expired - fetch a new one using the refresh token\n\t\t\t\tself.refresh_access_token if self.access_token_expired?\n\n\t\t\t\tself.access_token\n\t\t\tend",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token! : self.access_token\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token : self.access_token\n end",
"def valid_token\n return access_token if access_token && !expiring?\n return access_token if request_access_token\n raise 'No valid access token.'\n end",
"def fresh_token\n refresh! if token_expired?\n access_token\n end",
"def access_token\n refresh! if access_token_expires_at&.<= Time.now + 60 # time drift margin\n @access_token\n end",
"def fresh_token\n refresh! if expired?\n access_token\n end",
"def access_token\n # Fetch from cache. We can expect this to be `nil` if unset or expired.\n #\n access_token = read_cache\n\n return access_token if access_token\n\n fetch_new_access_token\n end",
"def valid_token\n access_token = find_or_create_doorkeeper_access_token\n create_doorkeeper_access_token if access_token.expired? || access_token.revoked?\n access_token\n end",
"def access_token\n return false unless session[:oauth]\n access_token = OAuth2::AccessToken.from_hash client, session[:oauth].dup\n if access_token.expired?\n access_token = OAuth2::AccessToken.from_hash(client, session[:oauth].dup).refresh!\n session[:oauth] = access_token.to_hash\n end\n @access_token ||= access_token\n end",
"def refresh_token()\n if @access_token_obj\n @access_token_obj.refresh_token\n else\n return nil\n end\n end",
"def get_access_token\n auth = storage['authentication']\n return auth['access_token'] if auth && auth['expires'] > Time.now.to_i\n\n auth = authenticate_client\n storage['authentication'] = auth\n auth['access_token']\n end",
"def access_token\n Rails.cache.fetch(\"googl_access_token\", expires_in: 50.minutes) do \n request = { query: { client_id: ENV['GOOGL_CLIENT_ID'],\n client_secret: ENV['GOOGL_CLIENT_SECRET'],\n refresh_token: ENV['GOOGL_REFRESH_TOKEN'],\n grant_type: \"refresh_token\"} }\n\n result = self.class.post(\"/oauth2/v3/token\", request)\n\n result.parsed_response[\"access_token\"]\n end\n end",
"def refresh_access_token()\n\n\t\tif(Time.now - @start_time) >=3000\n\t\t\tputs \"Access Token Expired .......Creating a new one\"\n\t\t\t@access_token = @new_token.get_access_token\n\t\t\t@start_time = Time.now\n\t\tend\n\tend",
"def refresh_access_token\n return false unless @oauth_access_token.expired?\n\n @oauth_access_token = @oauth_access_token.refresh!\n write_attribute :access_token, @oauth_access_token.token\n write_attribute :access_token_expires_at, @oauth_access_token.expires_at\n true\n end",
"def refresh(access_token)\n new_access_token = access_token.client.access_token!\n expires = Time.zone.at(decode_id_token(new_access_token.id_token).exp).to_datetime\n\n {\n access_token: new_access_token.access_token,\n expires_at: expires\n }\n rescue Rack::OAuth2::Client::Error\n # Refresh token was expired\n {}\n end",
"def access_token\n # Synchronization is needed, otherwise race condition may ensue:\n # Let's assume token has expired, and two threads ask for a new token.\n # Both proceed to fetch the token from remote server, both return,\n # but the first token is no longer valid.\n MUTEX.synchronize do\n token = Nordea::Siirto.redis.get(KEY)\n return token if token\n\n Nordea::Siirto.log('Requesting new access token...')\n payload = response.body\n\n token = payload['access_token']\n expires_in = payload['expires_in'] - EXPIRATION_BUFFER\n Nordea::Siirto.redis.set(KEY, token)\n Nordea::Siirto.redis.expire(KEY, expires_in)\n\n token\n end\n end",
"def update_token\n client.authorization.update_token!(oauth_data)\n if client.authorization.refresh_token && client.authorization.expired?\n client.authorization.fetch_access_token!\n end\n end",
"def fetch_or_refresh\n refresh_from_store\n fetch_and_write if client.expired?\n client.access_token\n end",
"def refresh_token\n return if token\n refresh_token!\n end",
"def access_token\n @access_token ||= ShakeTheCounter::Authentication.renew_access_token(client_id: id, client_secret: secret, refresh_token: refresh_token)[\"access_token\"]\n end",
"def refresh_token(token = @token)\n raise \"invalid token\" unless token\n @access_token ||= OAuth2::AccessToken.new(@oauth_client, token, :refresh_token => @refresh_token, :expires_at => @token_expires_at)\n if @access_token.expired?\n @access_token.refresh!\n @access_token_refreshed = true\n end\n end",
"def refresh_token_if_needed\n token_timestamp = decoded_jwt['exp']\n current_timestamp = DateTime.now.to_i\n return unless token_timestamp - current_timestamp <= 0\n\n refresh_token\n end",
"def access_token\n @access_token ||= begin\n if oauth_options[:oauth_verifier]\n request_token.get_access_token(:oauth_verifier => oauth_options[:oauth_verifier])\n else\n request_token.get_access_token\n end\n end\n end",
"def authenticate\n # if valid_access_token?\n # fetch_access_token\n # else\n get_new_access_token\n # end\n end",
"def renew_access_token!\n @access_token = nil\n true\n end",
"def get_access_token\n raise HyvesException, 'You need an request token to make get an access token' if request_token.nil?\n @access_token = request_token.get_access_token\n\n @userid = request_token.response[\"userid\"]\n @expiredate = Time.at(request_token.response[\"expiredate\"].to_i) if not request_token.response[\"expiredate\"].nil?\n\n @access_token\n end",
"def access_token\n @access_token ||= nil\n end",
"def isTokenExpired\n if Time.now.to_i - @access_token_timestamp >= access_token_expires\n puts \"had to reauthenticate\"\n self.authenticate\n end\n end",
"def valid_access_token(channel)\n Microsoft::RefreshOauthTokenService.new(channel: channel).access_token\n end",
"def refresh_access_token\n new_token = FireCloudClient.generate_access_token(self.service_account_credentials)\n new_expiry = Time.zone.now + new_token['expires_in']\n self.access_token = new_token\n self.expires_at = new_expiry\n new_token\n end",
"def access_token()\n if @access_token_obj\n @access_token_obj.token\n else\n return nil\n end\n end",
"def refresh_access_token!\n self.save! if refresh_access_token\n end",
"def refresh_token\n debug { \"Performing token refresh\" }\n return false if token.nil?\n return false if token['refresh_token'].nil?\n uri = URI.parse(token_account['token_endpoint'])\n endpoint_data = { path: uri.path }\n endpoint_data[:host] = uri.host if uri.host\n endpoint_data[:port] = uri.port if uri.port\n\n debug { \"Token refresh endpoint: #{endpoint_data.inspect}\" }\n\n return false unless endpoint_data[:path]\n\n response = request(\n {\n http_method: token_account['token_method'].downcase.to_sym,\n body: refresh_request_params,\n headers: {\n CONTENT_TYPE => token_account['token_post_content_type']\n }.merge(\n token_account['code_requires_basic_auth'] ? basic_auth_header : {}\n ),\n expects: [200, 201, 400, 401, 403],\n auth: false\n }.merge(endpoint_data)\n )\n\n if response && response['access_token']\n debug { \"Got response to refresh request\" }\n token['access_token'] = response['access_token']\n token['refresh_token'] = response['refresh_token']\n token['expires_at'] = in_to_at(response['expires_in'])\n token.config.write if token.respond_to?(:config)\n true\n else\n debug { \"Got null or bad response to refresh request: #{last_response.inspect}\" }\n false\n end\n rescue => ex\n error { \"Access token refresh exception\" }\n error { ex }\n false\n end",
"def retrieve_token!\n body = request_token\n # Refresh our token early so that it won't expire while a request is in-flight. We expect 15m\n # expirys for tokens but are careful not to trim the expiry by too much, just in case\n expires_in = body['expires_in'].seconds\n if expires_in - AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES > 0\n expires_in -= AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES\n end\n token = \"#{body['token_type']} #{body['access_token']}\"\n Rails.cache.write(AUTH_TOKEN_CACHE_KEY, token, expires_in: expires_in)\n token\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def check_access_token\n @access_token = session[:access_token]\n\n begin\n @client = Octokit::Client.new :access_token => @access_token\n @user = @client.user\n rescue => e\n # The token has been revoked, so invalidate the token in the session.\n session[:access_token] = nil\n authenticate!\n end\nend",
"def needs_refresh?\n @access_token.nil? ||\n (Time.now + TOKEN_BUFFER) > @expires_at\n end",
"def get_access_token\n\t\t\tif @access_token.nil?\n\t\t\t\t# do we have it cached on disk?\n\t\t\t\ttmp_file = get_access_token_file\n\n\t\t\t\tif File.exist? tmp_file\n\t\t\t\t\[email protected] 'Fetching cached auth token from disk'\n\t\t\t\t\tset_access_token(File.read(tmp_file).strip)\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t# try again, get a fresh token\n\t\t\tif @access_token.nil?\n\t\t\t\turi = URI(\"https://#{@club_name}.tidyclub.com/oauth/token\")\n\t\t\t\[email protected] \"Fetching a fresh token from #{uri}\"\n\t\t\t\thttps = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttps.use_ssl = true\n\t\t\t\tpayload = {\n\t\t\t\t\t\tclient_id: client_id,\n\t\t\t\t\t\tclient_secret: client_secret,\n\t\t\t\t\t\tusername: user_name,\n\t\t\t\t\t\tpassword: password,\n\t\t\t\t\t\tgrant_type: 'password'\n\t\t\t\t}\n\t\t\t\trequest = Net::HTTP::Post.new(uri.path)\n\n\t\t\t\trequest.set_form_data payload\n\t\t\t\tresponse = https.request(request)\n\n\t\t\t\tif response.content_type != 'application/json'\n\t\t\t\t\tmsg = \"Expecting a JSON response, got a response type of '#{response.content_type}' instead\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\n\t\t\t\tif response.code.to_i == 200\n\t\t\t\t\tr = JSON.parse response.body\n\t\t\t\t\tset_access_token r['access_token']\n\t\t\t\telse\n\t\t\t\t\tmsg = \"Authentication Failed - response code was: #{response.code} - #{response.message}\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\t\t\tend\n\t\t\t@access_token = nil if @access_token == ''\n\n\t\t\tif @access_token.nil?\n\t\t\t\tmsg = 'There is no valid access token'\n\t\t\t\[email protected] msg\n\t\t\t\traise AuthenticationError, msg\n\t\t\tend\n\n\t\t\t@access_token\n\t\tend",
"def refresh!\n now = Time.now\n raise RefreshTokenExpired if refresh_token_expires_at&.<= now\n\n data = refresh_token_request!\n\n @access_token = data[\"access_token\"]\n @access_token_expires_at = (now + data[\"expires_in\"])\n\n on_refresh&.call(@access_token, @access_token_expires_at)\n end",
"def get_access_token\n # Get the current token hash from session\n token_hash = session[:azure_token]\n\n client = OAuth2::Client.new(CLIENT_ID,\n CLIENT_SECRET,\n :site => 'https://login.microsoftonline.com',\n :authorize_url => '/common/oauth2/v2.0/authorize',\n :token_url => '/common/oauth2/v2.0/token')\n\n token = OAuth2::AccessToken.from_hash(client, token_hash)\n\n # Check if token is expired, refresh if so\n if token.expired?\n new_token = token.refresh!\n # Save new token\n session[:azure_token] = new_token.to_hash\n access_token = new_token.token\n else\n access_token = token.token\n end\n end",
"def refresh_token\n authorize current_user\n original = current_user.api_token\n current_user.generate_token!\n @success = current_user.api_token != original\n end",
"def get_token\n if @token && @valid_until && @valid_until > Time.now + 10\n @token\n else\n renew_token\n end\n end",
"def refreshToken\n # is there a token? (and is it's timestamp not older than 24h?)\n if @token.nil? or @tokenTimeStamp < Time.now - 86400\n @token = getToken(@email,@password)\n @tokenTimeStamp = Time.now\n end\n end",
"def refresh!\n response = request_token_from_google\n data = JSON.parse(response.body)\n if data[\"access_token\"].present?\n update_attributes(access_token: data['access_token'], expires_at: Time.now + (data['expires_in'].to_i).seconds)\n else\n puts data[\"error_description\"]\n end\n end",
"def refresh_access_token(access_token)\n begin\n client, auth = google_api_client_auth\n auth.refresh_token = access_token\n auth.refresh!\n auth.access_token\n rescue\n puts \"Failed to refresh Google OAuth access token\"\n nil\n end\n end",
"def maybe_renewing_access_token(&block)\n first_attempt_request(&block) or (renew_access_token! and last_attempt_request(&block))\n end",
"def access_token_expired?\n\t\taccess_token_expires_at && access_token_expires_at < Time.zone.now\n\tend",
"def refresh_access_token\n self.expires_at = Time.now + 3600 \n save\n end",
"def access_token_was_refreshed; end",
"def refresh_access_token!\n @access_token = access_token.refresh!\n end",
"def token_refresh!\n self.access_token = access_token.refresh!\n end",
"def get_access_token\n return @access_token if authorized?\n\n if @request_token.nil?\n raise DropboxAuthError.new(\"No request token. You must set this or get an authorize url first.\")\n end\n\n @access_token = get_token(\"/access_token\", @request_token, \"Couldn't get access token.\")\n end",
"def verify_access_token\n if bypass_auth?\n true\n else\n authenticate_or_request_with_http_token do |token, opts|\n current_user && token && current_user.access_token.token == token\n end\n end\n end",
"def check_token\n # Return if there are no tokens\n return if session['oauth_token'].nil?\n\n # If the token is older than two weeks, delete it\n if session['created_at'] < (Time.zone.now - 2.weeks).to_i\n clear_credentials\n return\n end\n\n # Make API request to renew the token\n url = URI('https://login.zype.com/oauth/token')\n raw_response = make_login_request(url, refresh_token: session['refresh_token'], grant_type: 'refresh_token')\n\n # Check if response is successful\n unless raw_response.is_a?(Net::HTTPSuccess)\n clear_credentials\n return\n end\n\n # Try to parse the response\n parsed_response = parse_response(raw_response, 'check_login')\n\n # If the response cannot be parsed, there is something wrong, but the parsing\n # functions logs the error, shows an alert to the user and redirects\n unless parsed_response\n clear_credentials\n return\n end\n\n # Set tokens on session\n # TO DO: Persist it, maybe in Redis\n session['oauth_token'] = parsed_response['access_token']\n session['refresh_token'] = parsed_response['refresh_token']\n end",
"def auth_token\n return regenerate_auth_token if expired?\n\n authentication.auth_token\n end",
"def valid_tokens\n clear_expired_tokens\n access_tokens.pluck(:token)\n end",
"def get_oauth_token(authorization_code, current_user, query_params = nil)\n begin\n client_auth = DropboxOAuth2Flow.new(APP_CONFIG['oauth']['dropbox']['client_id'], APP_CONFIG['oauth']['dropbox']['client_secret'], APP_CONFIG['oauth']['dropbox']['redirect_url'], {:dropbox_auth_csrf_token => query_params[:state]}, :dropbox_auth_csrf_token)\n access_token, user_id, url_state = client_auth.finish(query_params)\n rescue\n return false\n end\n \n # Dropbox doesnt seem to support the oauth token refresh and no doc's explaining when tokens expire.\n saved = OauthDriveToken.create_or_update(:user => current_user, \n :access_token => access_token, \n :refresh_token => 'not_supported',\n :client_number => user_id, \n :expires_at => Time.now,\n :provider_number => APP_CONFIG['oauth']['dropbox']['provider_number'])\n saved\n end",
"def access_token\n creds = JSON.parse(File.read(FILE_CREDS))\n authorization = Google::Auth::UserRefreshCredentials.new(\n client_id: creds['installed']['client_id'],\n client_secret: creds['installed']['client_secret'],\n scope: SCOPE,\n refresh_token: refresh_token,\n expires_at: (Time.now+100).utc,\n grant_type: 'authorization_code')\n authorization.fetch_access_token!\n authorization.access_token\nend",
"def refresh_access_token!\n @access_token = access_token.refresh!\n self.class.default_params :access_token => @access_token.token\n @access_token\n end",
"def refresh_access_token(refresh_token = @config.REFRESH_TOKEN)\r\n get_new_access_token(refresh_token)\r\n end",
"def refresh_token?\n if (@token_timer + 6000) < Time.now\n self.get_token\n true\n else\n false\n end\n end",
"def token_expired?\n expiry = Time.at(self.gplus_token_expires_at.to_i) \n if expiry < Time.now \n data = {\n client_id: '476602585408-3fiklaclekbinfmbd2lsdjcur1u21ril.apps.googleusercontent.com',\n client_secret: 'RX-7Mq_SXT1DJSJsYJtLj6a4',\n refresh_token: self.gplus_refresh_token,\n grant_type: \"refresh_token\"\n }\n @response = ActiveSupport::JSON.decode(RestClient.post \"https://accounts.google.com/o/oauth2/token\", data)\n if @response[\"access_token\"].present?\n self.gplus_token = @response[\"access_token\"]\n self.gplus_token_expires_at = @response[\"expires_in\"]\n self.save\n end\n end\n end",
"def token\n refresh_token if needs_token_refresh?\n return @token\n end",
"def get_access_token(authz_code = nil)\n if @config.grant_type == 'client_credentials'\n $LOG.i \"getting access token\"\n\t @access_token = @oauth2_client.client_credentials.get_token\n $LOG.i \"got access token\", @access_token\n else\n $LOG.i \"getting access and refresh token pair\"\n\t @access_token = @oauth2_client.auth_code.get_token(authz_code, :redirect_uri => @config.redirect_uri)\n $LOG.i \"got access and refresh token pair\", @access_token\n end\n\n\trefresh_config_from_access_token\n\n\t@access_token\n end",
"def refresh_token(oauth_drive_token)\n begin\n @client.authorization.fetch_access_token!\n rescue\n # Error when updating, so lets remove token and user will have to re-autrhorize\n oauth_drive_token.destroy\n return false\n end\n \n saved = OauthDriveToken.create_or_update(:user => oauth_drive_token.user, \n :access_token => @client.authorization.access_token, \n :refresh_token => @client.authorization.refresh_token,\n :expires_at => Time.now + @client.authorization.expires_in.seconds,\n :provider_number => APP_CONFIG['oauth']['google']['provider_number'])\n\n # Hasn't been updated, so lets remove token\n oauth_drive_token.destroy if !saved\n \n saved\n end",
"def getCurrentToken\n\t\t\tif !@accessToken\n\t\t\t\treturn false\n\t\t\tend\n\n\t\t\t@accessToken\n\t\tend",
"def refresh_token\n @token = @authenticator.refresh_token\n end",
"def request_access_token\n Firebase.logger.info('Requesting access token...')\n Firebase.logger.debug(\"token_uri: #{token_uri}\")\n res = Neko::HTTP.post_form(token_uri, jwt)\n Firebase.logger.debug(\"HTTP response code: #{res[:code]}\")\n if res.class == Hash && res[:code] == 200\n data = JSON.parse(res[:body], {symbolize_names: true})\n @access_token = data[:access_token]\n @expires = Time.now + data[:expires_in]\n Firebase.logger.info('Access token acquired.')\n s = \"Token #{@access_token.length} bytes, expires #{@expires}\"\n Firebase.logger.debug(s)\n return true\n else\n Firebase.logger.error('Access token request failed.')\n Firebase.logger.debug(\"HTTP #{res[:code]} #{res[:message]}\")\n end\n return false\n end",
"def authenticated?\n !expired? && respond_to?(:access_token) && access_token.present?\n end",
"def access_token\n @auth.access_token\n end",
"def get_access_token\n\t\treturn @credentials.get_access_token\n\tend",
"def validate_token_hash\n if @token_request_at and\n @token_hash and @token_hash['expires_in'] and\n (Time.now - @token_request_at) > @token_hash['expires_in'].to_i\n @token_hash = nil\n elsif @token_request_at and\n @token_hash and @token_hash['expires_in']\n @token_hash['access_token']\n else\n puts \"start get token ...\"\n end\n end",
"def refresh_token\n @auth.refresh_token\n end",
"def refresh_access_token\n\t\t\t\trequire \"open-uri\"\n\t\t\t\trequire \"net/http\"\n\t\t\t\trequire \"openssl\"\n\t\t\t\trequire \"base64\"\n\n\t\t\t\turi = URI.parse(\"#{self.add_on.jive_url}/oauth2/token\")\n\t\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttp.use_ssl = true\n\n\t\t\t\trequest = Net::HTTP::Post.new(uri.request_uri)\n\t\t\t\trequest.basic_auth self.add_on.client_id, self.add_on.client_secret\n\t\t\t\trequest.set_form_data({\n\t\t\t\t\t\"refresh_token\" => \"#{self.refresh_token}\",\n\t\t\t\t\t\"grant_type\" => \"refresh_token\",\n\t\t\t\t})\n\n\t\t\t\tresponse = http.request(request)\n\t\t\t\tjson_body = JSON.parse(response.body)\n\n\t\t\t\tif (response.code.to_i != 200)\n\t\t\t\t\traise RuntimeError, json_body[\"error\"].to_s.upcase\n\t\t\t\tend\n\n\t\t\t\tself.access_token = json_body[\"access_token\"]\n\t\t\t\tself.expires_in = json_body[\"expires_in\"]\n\t\t\t\tself.expires_at = json_body[\"expires_in\"].to_i.seconds.from_now\n\t\t\t\tself.save\n\t\t\tend",
"def check_validity\n if @expires_at == nil\n raise OAuthSessionError, \"Expiration not properly initialized.\"\n end\n if @expires_at < Time.new\n if not do_refresh\n raise OAuthSessionError, \"Token could not be refreshed.\"\n end\n end\n return true\n end",
"def validate(expiration_buffer_sec = 0)\n return true if (Time.now + expiration_buffer_sec).to_i < expires_on\n\n unless refresh_token\n logger.verbose('Cached token is almost expired but no refresh token ' \\\n 'is available.')\n return false\n end\n logger.verbose('Cached token is almost expired, attempting to refresh ' \\\n ' with refresh token.')\n refresh_response = refresh\n if refresh_response.instance_of? SuccessResponse\n logger.verbose('Successfully refreshed token in cache.')\n @token_response = refresh_response\n true\n else\n logger.warn('Failed to refresh token in cache with refresh token.')\n false\n end\n end",
"def fresh_hubstaff_access_token\n raise 'Organiaztion not connected to HB. Please edit hubstaff start auth code.' if hubstaff_token_will_end.blank?\n\n # still fresh\n return hubstaff_access_token if hubstaff_token_will_end - 2.hours > DateTime.now\n\n res = HubstaffClient.new.refresh_access_token_request hubstaff_refresh_token\n\n raise StandardError, res.parsed_response['error'] if res.code != 200\n\n self.hubstaff_access_token = res.parsed_response['access_token']\n self.hubstaff_refresh_token = res.parsed_response['refresh_token']\n self.hubstaff_token_get_at = DateTime.now\n self.hubstaff_token_will_end = DateTime.now + (res.parsed_response['expires_in'].to_i / 60.0 / 60.0).round.hours\n\n self.save\n\n hubstaff_access_token\n end",
"def fb_access_token_expired\n self.access_token = nil\n save!\n end",
"def valid_access_token?\n token_file = '/opt/gluu-server/etc/certs/api_token.json'\n return false unless File.exist? token_file\n\n token_config = JSON.parse(File.read(token_file))\n expired = token_config['exp'] < Time.now.to_i\n return false if expired\n\n return false unless token_config['token']\n\n true\n end",
"def check_access_token\r\n\t\t\t\ttoken = request.headers[\"X-Access-Token\"] || nil\r\n\t\t\t\t\r\n\t\t\t\tif token\r\n\t\t\t\t\tfind_token = ApiKey.find_by_access_token(token)\r\n\r\n\t\t\t\t\tif find_token.nil?\r\n\t\t\t\t\t\tinvalid_access_token\r\n\t\t\t\t\tend\r\n\t\t\t\telse\r\n\t\t\t\t\tinvalid_access_token\r\n\t\t\t\tend\r\n\t\t\tend",
"def refresh_token\n @refresh_token ||= nil\n end",
"def access_token\n @attributes[:access_token] || client.token\n end",
"def access_token\n @attributes[:access_token] || client.token\n end",
"def access_token\n @attributes[:access_token] || client.token\n end",
"def refresh! options = {}\n fetch_access_token! options\n end",
"def access_token\n api_key.access_token rescue \"\"\n end",
"def access_token\n user_token = @user_token\n goat.transaction do\n if user_token.access_token.nil?\n user_token.access_token = request_token.get_access_token\n if !user_token.access_token.nil?\n goat[user_token.user] = user_token\n end\n end\n end\n @user_token = user_token\n @user_token.access_token\n end",
"def fetch_access_token! options = {}\n token_hash = fetch_access_token options\n if token_hash\n # No-op for grant types other than `authorization_code`.\n # An authorization code is a one-time use token and is immediately\n # revoked after usage.\n self.code = nil\n self.issued_at = Time.now\n update_token! token_hash\n end\n token_hash\n end",
"def generate_access_token\n begin\n self.access_token = User.new_token\n end while ApiKey.exists?(access_token: access_token)\n end",
"def token_authenticated?\n !!(@access_token && (@access_token_expires_at.nil? || @access_token_expires_at > Time.now))\n end",
"def refresh_access!\n response = auth_connection.post(\n \"/api/v1/access_token\",\n grant_type: \"refresh_token\",\n refresh_token: access.refresh_token\n )\n access.refreshed!(response.body)\n reset_connection!\n end",
"def check_access_token\n @access_token = session[:access_token]\n\n begin\n @client = Octokit::Client.new :access_token => @access_token\n @user = @client.find_user_installations\n rescue => e\n # The token has been revoked, so invalidate the token in the session.\n session[:access_token] = nil\n authenticate!\n end\nend",
"def check_token\n if File.exist?(@token_file)\n refresh_token = open(@token_file) { |f| f.read }.chomp\n g_cal.login_with_refresh_token(refresh_token)\n else\n # A user needs to approve access in order to work with their calendars.\n puts \"Visit the following web page in your browser and approve access.\"\n puts g_cal.authorize_url\n puts \"\\nCopy the code that Google returned and paste it here:\"\n\n # Pass the ONE TIME USE access code here to login and get a refresh token that you can use for access from now on.\n refresh_token = g_cal.login_with_auth_code($stdin.gets.chomp)\n\n # Save token to TOKEN_FILE\n File.open(@token_file, 'w') { |f| f.write(refresh_token) }\n puts \"Token saved to #{@token_file}\"\n end\n end",
"def token\n refresh_token! if token_expired?\n super\n end",
"def use_refresh_token(refresh_token, use_client_id=nil)\n if use_client_id\n self.client_id = use_client_id\n end\n @access_token = nil\n url = \"#{@base_url}/oauth/token\"\n params = {grant_type: 'refresh_token', scope:'write', client_id: self.client_id}\n payload = {refresh_token: refresh_token}\n headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }\n opts = {method: :post, url: url, headers: headers, params: params, payload: payload, timeout: 5}\n response = execute(opts)\n return response if @dry_run\n @access_token = response['access_token']\n @refresh_token = response['refresh_token']\n if response['expires_in'] != nil\n @expires_at = Time.now + response['expires_in']\n end\n return response\n end",
"def access_token\n @access_token\n end",
"def authentication_token\n if session[:authentication_token]\n if DateTime.now >= session[:expires_at]\n refresh_token\n else\n session[:authentication_token]\n end\n else\n nil\n end\n end",
"def validate_token(provided_token)\n clear_expired_tokens\n token_object = access_tokens.find_by_token(provided_token)\n return false if !token_object\n token_object.update_attribute(:token_expire, Time.now + DEFAULT_TOKEN_EXPIRE)\n true\n end"
] | [
"0.8641398",
"0.8559956",
"0.85573274",
"0.82309383",
"0.81023806",
"0.80696386",
"0.8045107",
"0.78940094",
"0.78896165",
"0.7755664",
"0.77240986",
"0.75344205",
"0.74539703",
"0.7366186",
"0.7357246",
"0.73560435",
"0.7340601",
"0.72907376",
"0.7268342",
"0.7219535",
"0.71954685",
"0.7194226",
"0.71462315",
"0.71411484",
"0.71410084",
"0.70963234",
"0.7085618",
"0.7026322",
"0.70244265",
"0.7021685",
"0.7018383",
"0.7018255",
"0.70125663",
"0.69697356",
"0.696831",
"0.69653606",
"0.69653606",
"0.69398564",
"0.69361746",
"0.6930801",
"0.69299084",
"0.69195294",
"0.6918475",
"0.69168",
"0.69160515",
"0.6910359",
"0.6904427",
"0.6890866",
"0.68817127",
"0.6876443",
"0.68745446",
"0.68506044",
"0.6829813",
"0.68232375",
"0.6816481",
"0.680745",
"0.6790916",
"0.67886966",
"0.6762446",
"0.67623997",
"0.6757309",
"0.67385584",
"0.6735349",
"0.6724952",
"0.67013687",
"0.6698926",
"0.66665775",
"0.66490155",
"0.66489357",
"0.6645297",
"0.66397524",
"0.6634027",
"0.6631969",
"0.6609859",
"0.66097116",
"0.66091955",
"0.6582821",
"0.6555387",
"0.65454084",
"0.65409195",
"0.65336674",
"0.6531224",
"0.6529247",
"0.65289676",
"0.65289676",
"0.65289676",
"0.6522313",
"0.6516164",
"0.65108275",
"0.64828426",
"0.64710414",
"0.6463342",
"0.64592123",
"0.6454005",
"0.64473724",
"0.6442579",
"0.6442437",
"0.64409685",
"0.6437261",
"0.64370763"
] | 0.77385294 | 10 |
Checks if the token needs a refesh by checking if the token is nil or (about to) expire(d) | def needs_refresh?
@access_token.nil? ||
(Time.now + TOKEN_BUFFER) > @expires_at
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def token_expired?\n @token.nil? || Time.now >= @token_expires_on + expiration_threshold\n end",
"def token_expired\n @token.nil? || Time.now >= @token_expires_on + expiration_threshold\n end",
"def token_expired?\n return true\n expires_at < Time.now if expires_at?\n end",
"def token_expired?\n self.expires < Time.zone.now.to_i\n end",
"def is_token_expired?\n (Time.now - self.updated_at) > 3300\n end",
"def validate_token(provided_token)\n clear_expired_tokens\n token_object = access_tokens.find_by_token(provided_token)\n return false if !token_object\n token_object.update_attribute(:token_expire, Time.now + DEFAULT_TOKEN_EXPIRE)\n true\n end",
"def validate_token_hash\n if @token_request_at and\n @token_hash and @token_hash['expires_in'] and\n (Time.now - @token_request_at) > @token_hash['expires_in'].to_i\n @token_hash = nil\n elsif @token_request_at and\n @token_hash and @token_hash['expires_in']\n @token_hash['access_token']\n else\n puts \"start get token ...\"\n end\n end",
"def expired?(token)\n expires_on = token[/&?ExpiresOn=([^&]+)/, 1]\n expires_on.to_i < Time.now.to_i\n end",
"def expired?\n @token.expired?(@expires_in_buffer)\n end",
"def check_token_expiration\n return unless @person.password_reset_expired?\n\n flash[:danger] = I18n.t('password_reset.expired_token')\n redirect_to new_password_reset_url\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def refresh_token_if_needed\n token_timestamp = decoded_jwt['exp']\n current_timestamp = DateTime.now.to_i\n return unless token_timestamp - current_timestamp <= 0\n\n refresh_token\n end",
"def isTokenExpired\n if Time.now.to_i - @access_token_timestamp >= access_token_expires\n puts \"had to reauthenticate\"\n self.authenticate\n end\n end",
"def check_validity\n if @expires_at == nil\n raise OAuthSessionError, \"Expiration not properly initialized.\"\n end\n if @expires_at < Time.new\n if not do_refresh\n raise OAuthSessionError, \"Token could not be refreshed.\"\n end\n end\n return true\n end",
"def validate(expiration_buffer_sec = 0)\n return true if (Time.now + expiration_buffer_sec).to_i < expires_on\n\n unless refresh_token\n logger.verbose('Cached token is almost expired but no refresh token ' \\\n 'is available.')\n return false\n end\n logger.verbose('Cached token is almost expired, attempting to refresh ' \\\n ' with refresh token.')\n refresh_response = refresh\n if refresh_response.instance_of? SuccessResponse\n logger.verbose('Successfully refreshed token in cache.')\n @token_response = refresh_response\n true\n else\n logger.warn('Failed to refresh token in cache with refresh token.')\n false\n end\n end",
"def needs_token_refresh?\n !@token || @authenticator.needs_token_refresh?\n end",
"def token_valid?\n @session_token and @toodle_token_death > Time.now\n end",
"def refresh_token?\n if (@token_timer + 6000) < Time.now\n self.get_token\n true\n else\n false\n end\n end",
"def validate_token(provided_token, extend_expire = true)\n clear_expired_tokens\n token_object = access_tokens.find_by_token(provided_token)\n return false if !token_object\n if extend_expire\n token_object.update_attribute(:token_expire, Time.now + DEFAULT_TOKEN_EXPIRE)\n end\n true\n end",
"def valid_token?\r\n token = ::AuthToken.where(user_id: decoded_auth_token[:user_id]).newer.first\r\n token&.token == auth_token && token.expire_at >= Time.now if token.present?\r\n end",
"def maybe_reauthenticate\n if @keystone_token_expiration < Time.now + 2*@timeout\n @logger.info \"Permanent token will expire soon. Re-authenticating...\"\n authenticate\n end\n end",
"def access_token_expired?\n\t\taccess_token_expires_at && access_token_expires_at < Time.zone.now\n\tend",
"def valid_token\n unless !value_changed? || token_data(refresh: true).is_valid\n errors.add(\n :value,\n I18n.translate(\n 'fbsync.activerecord.errors.token.invalid_token',\n expires_at: I18n.localize(token_data.expires_at)\n )\n )\n end\n end",
"def access_token_expired?\n\t\t\t\treturn false if self.expires_at.nil?\n\n\t\t\t\t# Expiration date less than now == expired\n\t\t\t\tself.expires_at < Time.now\n\t\t\tend",
"def validate_token\n if self.transaction_token_created_at + 720.minutes > Time.now\n true\n else\n false\n end\n end",
"def token_can_be_reused?(token, client_id)\n # ghetto HashWithIndifferentAccess\n updated_at = self.tokens[client_id]['updated_at'] || self.tokens[client_id][:updated_at]\n last_token = self.tokens[client_id]['last_token'] || self.tokens[client_id][:last_token]\n\n\n return true if (\n # ensure that the last token and its creation time exist\n updated_at && last_token &&\n\n # ensure that previous token falls within the batch buffer throttle time of the last request\n Time.parse(updated_at) > Time.now - DeviseTokenAuth.batch_request_buffer_throttle &&\n\n # ensure that the token is valid\n ::BCrypt::Password.new(last_token) == token\n )\n end",
"def password_reset_token_expired?\n sent_reset_at < 1.hour.ago\n end",
"def access_token_was_refreshed; end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token! : self.access_token\n end",
"def ensure_token\n if self.token_expiration and Time.now > self.token_expiration\n self.token = nil\n end\n self.token ||= self.generate_token\n self.token_expiration = Time.now + 1.day\n self.save\n return self.token\n end",
"def token_can_be_reused?(token, client_id)\n return true if (\n # ensure that the last token and its creation time exist\n self.tokens[client_id]['updated_at'] and\n self.tokens[client_id]['last_token'] and\n\n # ensure that previous token falls within the batch buffer throttle time of the last request\n Time.parse(self.tokens[client_id]['updated_at']) > Time.now - DeviseTokenAuth.batch_request_buffer_throttle and\n\n # ensure that the token is valid\n BCrypt::Password.new(self.tokens[client_id]['last_token']) == token\n )\n end",
"def valid_access_token\n\t\t\t\t# The token we have stored is expired - fetch a new one using the refresh token\n\t\t\t\tself.refresh_access_token if self.access_token_expired?\n\n\t\t\t\tself.access_token\n\t\t\tend",
"def refreshToken\n # is there a token? (and is it's timestamp not older than 24h?)\n if @token.nil? or @tokenTimeStamp < Time.now - 86400\n @token = getToken(@email,@password)\n @tokenTimeStamp = Time.now\n end\n end",
"def activation_token_expired?\n activation_sent_at < 7.days.ago\n end",
"def fb_access_token_expired\n self.access_token = nil\n save!\n end",
"def refresh_expired?\n can_refresh_expire? && @refresh_expiry < Time.now.to_i\n end",
"def is_authorized?\n !!token && !token.expired?\n end",
"def is_authorized?\n !!token && !token.expired?\n end",
"def has_preview_url_expired?\n input_ts = @params['ts'].to_i\n threshold_time = Time.now - 5 * 60 # check if token is older than 5 minutes\n input_ts < threshold_time.to_i\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token : self.access_token\n end",
"def ensure_auth_token!\n reset_auth_token! if auth_token.blank?\n end",
"def tokens_refreshed?\n\t current_user and current_user.refreshed?\n\tend",
"def valid_token\n access_token = find_or_create_doorkeeper_access_token\n create_doorkeeper_access_token if access_token.expired? || access_token.revoked?\n access_token\n end",
"def token_expired?\n expiry = Time.at(self.gplus_token_expires_at.to_i) \n if expiry < Time.now \n data = {\n client_id: '476602585408-3fiklaclekbinfmbd2lsdjcur1u21ril.apps.googleusercontent.com',\n client_secret: 'RX-7Mq_SXT1DJSJsYJtLj6a4',\n refresh_token: self.gplus_refresh_token,\n grant_type: \"refresh_token\"\n }\n @response = ActiveSupport::JSON.decode(RestClient.post \"https://accounts.google.com/o/oauth2/token\", data)\n if @response[\"access_token\"].present?\n self.gplus_token = @response[\"access_token\"]\n self.gplus_token_expires_at = @response[\"expires_in\"]\n self.save\n end\n end\n end",
"def expire!\n token = nil\n save!\n end",
"def expired?\n self.expires_at && Time.now > self.expires_at\n end",
"def valid_token\n return access_token if access_token && !expiring?\n return access_token if request_access_token\n raise 'No valid access token.'\n end",
"def expired?; end",
"def check_expiration\n return unless @user.password_reset_expired?\n display_flash(:danger, 'Password reset token has expired.')\n redirect_to new_password_reset_url\n end",
"def retrieve_missing_token_info\n response = JSON.parse @token.get('/oauth/token/info').body\n\n if response['error']\n response['hint'] = 'Reauthorization may be required.'\n @token = response\n else\n time_left = response['expires_in_seconds']\n @token.instance_variable_set '@expires_at', (Time.now.to_i + time_left)\n end\n end",
"def expired?\n end",
"def expired?\n @expires_at <= Time.now\n end",
"def expired?\n !respond_to?(:expires_at) || expires_at < Time.current\n end",
"def expired?\n can_expire? && (self.expires_in + self.time_created) < Time.now.to_i\n end",
"def expired?\n Time.now > @expires\n end",
"def expired?\n not valid?\n end",
"def expired?\n can_expire? && @expiry < Time.now.to_i\n end",
"def expired?\n expires_at && Time.now > expires_at\n end",
"def expired?\n Time.now > expiration if expiration\n end",
"def token_expired?\r\n begin\r\n conditions_element = REXML::XPath.first(document,\"/p:Response/a:Assertion/a:Conditions\", { \"p\" => PROTOCOL, \"a\" => ASSERTION })\r\n raise SA1012Exception if conditions_element.nil?\r\n raise SA1003Exception if conditions_element.attribute('NotBefore') and Time.now.utc < Time.parse(conditions_element.attribute('NotBefore').value)\r\n raise SA1004Exception if conditions_element.attribute('NotOnOrAfter') and Time.now.utc >= Time.parse(conditions_element.attribute('NotOnOrAfter').value)\r\n rescue RuntimeError => exp\r\n Rails.logger.error \"#{exp.class} - #{exp.message}\"\r\n return true\r\n else\r\n return false\r\n end\r\n end",
"def not_expired?\n self.expires_at && Time.now <= self.expires_at\n end",
"def expired?\n\n end",
"def verify\n @cache[:last_accessed] = nil if\n @cache.has_key?(:last_accessed) &&\n @cache[:last_accessed].to_date != Date.today\n end",
"def expired?\n if expires?\n Time.now >= expires_at\n else\n false\n end\n end",
"def create_or_renew_token()\n calculate_expiry_time()\n end",
"def expired?\n Time.current >= expires_at\n end",
"def expired?\n expires && expires < Time.now\n end",
"def remember_token?\n remember_token_expires_at && Time.now.utc < remember_token_expires_at \n end",
"def remember_token?\n remember_token_expires_at && Time.now.utc < remember_token_expires_at \n end",
"def remember_token?\n remember_token_expires_at && Time.now.utc < remember_token_expires_at \n end",
"def expired?\n expires_at && expires_at <= Time.now\n end",
"def can_refresh_expire?\n return !!@refresh_expiry\n end",
"def expired?\n return if missing?\n\n validity < (reference_time - time)\n end",
"def expired?\n false\n end",
"def can_expire?\n return !!self.expires_in && !!self.time_created\n end",
"def remember_token?\n remember_token_expires_at && Time.now.utc < remember_token_expires_at\n end",
"def expired?\n self.expires_at && Time.now.utc > self.expires_at\n end",
"def check_expiration\n return unless @user.password_reset_expired?\n\n render json: {\n success: false,\n message: \"Reset password token has expired.\"\n }, status: :bad_request\n end",
"def expired?\n !expires_at.nil? && Time.now >= expires_at\n end",
"def expired?\n return true if expires - Time.now <= 0\n return false\n end",
"def verify_bearer\n if expired?(@bearer_info[:expire_time])\n @bearer_info = new_bearer(@bearer_info)\n @bearer_token = @bearer_info[:token]\n end\n end",
"def needs_refresh?\n !respond_to?(:created_at) || ((Time.at(created_at) + expires_in.seconds) < Time.current - 1.day)\n end",
"def can_expire?\n return !!@expiry\n end",
"def expired?\n expires? && (expires_at < Time.now.to_i)\n end",
"def check_expiration\n return unless @user.password_reset_expired?\n flash[:alert] = t('user_mailer.password_reset.expired_token')\n redirect_to new_password_reset_url\n end",
"def token\n refresh_token! if token_expired?\n super\n end",
"def tgt_expired?\n return true if @last_updated.nil? or @ticket_granting_ticket.nil?\n (@last_updated + 5) < Time.now.to_i # TGTs have an 8 hour life\n end",
"def valid_token?\n five_minutes_ago = DateTime.now - 5.minutes\n params[:timestamp].to_i > five_minutes_ago.to_i &&\n params[:token] == Scalingo::SsoController.generate_authentication_token(params[:id], params[:timestamp])\n end",
"def refresh_token\n get_comm_token if Time.now.to_i - @comm_token_ttl > TOKEN_TTL\n end",
"def refresh_token\n get_comm_token if Time.now.to_i - @comm_token_ttl > TOKEN_TTL\n end",
"def expire_tokens!\n update_tokens(nil)\n end",
"def remember_token?\n remember_token_expires_at && Time.now < remember_token_expires_at\n end",
"def invalidate_token\n update_attribute(:token, nil)\n update_attribute(:token_created_at, Time.now)\n end",
"def expired?\n return false unless expires_at\n expires_at < Time.now\n end",
"def valid_token?\n return false unless token\n begin\n # We use rate limit as its a fast and free way to\n # test the GitHub token.\n octokit.rate_limit\n rescue Octokit::ClientError\n return false\n end\n true\n end",
"def can_expire?\n false\n end",
"def expired?\n DateTime.now > @expires\n end",
"def check_expiration\n if @ngo.password_reset_expired?\n flash[:danger] = \"Password reset link has expired.\"\n redirect_to new_password_reset_url\n end\n end",
"def expired?\n @expires_in && @created_at + @expires_in <= Time.now.to_f\n end"
] | [
"0.77848905",
"0.77534103",
"0.7365735",
"0.7357167",
"0.7348214",
"0.7289499",
"0.7273703",
"0.72273326",
"0.71565",
"0.7098255",
"0.70725983",
"0.70725983",
"0.70694137",
"0.7040754",
"0.699659",
"0.69791883",
"0.6956492",
"0.69498557",
"0.694866",
"0.6942055",
"0.6921797",
"0.6869773",
"0.6863225",
"0.67700374",
"0.6766648",
"0.6759608",
"0.6710384",
"0.6697905",
"0.66946316",
"0.66683686",
"0.6664563",
"0.66486365",
"0.6630787",
"0.660309",
"0.66026556",
"0.659045",
"0.65767795",
"0.6568208",
"0.6568208",
"0.6556101",
"0.65371895",
"0.65113187",
"0.64981306",
"0.6497998",
"0.6489032",
"0.64885145",
"0.64693",
"0.64675725",
"0.645556",
"0.6454825",
"0.6453771",
"0.64505845",
"0.64431524",
"0.64396197",
"0.64372545",
"0.64301443",
"0.6429762",
"0.6418084",
"0.64096224",
"0.6406935",
"0.6400561",
"0.638629",
"0.63842076",
"0.6373683",
"0.6372362",
"0.63657296",
"0.6363313",
"0.6357083",
"0.63566065",
"0.63566065",
"0.63566065",
"0.6353832",
"0.63506025",
"0.63504755",
"0.63465637",
"0.6327589",
"0.6327346",
"0.6323916",
"0.6322324",
"0.6317337",
"0.6296731",
"0.6296198",
"0.6293242",
"0.6263738",
"0.62619",
"0.6252742",
"0.625233",
"0.62516725",
"0.6249392",
"0.62459934",
"0.62459934",
"0.6245258",
"0.6236845",
"0.6235651",
"0.62328565",
"0.62326235",
"0.6227124",
"0.622182",
"0.6220596",
"0.62197846"
] | 0.69156355 | 21 |
Fetches a new access token and stores it and its expiry date | def update_access_token
response = fetch_access_token
store_access_token(response.result)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fresh_token\n refresh! if expired?\n access_token\n end",
"def fresh_token\n refresh! if token_expired?\n access_token\n end",
"def refresh_access_token\n new_token = FireCloudClient.generate_access_token(self.service_account_credentials)\n new_expiry = Time.zone.now + new_token['expires_in']\n self.access_token = new_token\n self.expires_at = new_expiry\n new_token\n end",
"def access_token\n refresh! if access_token_expires_at&.<= Time.now + 60 # time drift margin\n @access_token\n end",
"def refresh_access_token\n self.expires_at = Time.now + 3600 \n save\n end",
"def refresh_access_token()\n\n\t\tif(Time.now - @start_time) >=3000\n\t\t\tputs \"Access Token Expired .......Creating a new one\"\n\t\t\t@access_token = @new_token.get_access_token\n\t\t\t@start_time = Time.now\n\t\tend\n\tend",
"def generate_access_token\n self.access_token ||= self.create_access_token\n save && access_token\n end",
"def access_token\n # Fetch from cache. We can expect this to be `nil` if unset or expired.\n #\n access_token = read_cache\n\n return access_token if access_token\n\n fetch_new_access_token\n end",
"def get_access_token\n raise HyvesException, 'You need an request token to make get an access token' if request_token.nil?\n @access_token = request_token.get_access_token\n\n @userid = request_token.response[\"userid\"]\n @expiredate = Time.at(request_token.response[\"expiredate\"].to_i) if not request_token.response[\"expiredate\"].nil?\n\n @access_token\n end",
"def get_new_access_token\n now = Time.now\n params = {\n body: {\n grant_type: 'urn:ietf:params:oauth:grant-type:uma-ticket',\n ticket: retrieve_ticket,\n client_id: key_info['oxtrust_client_id'],\n client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n client_assertion: generate_json_web_token(now),\n scope: 'oxtrust-api-read oxtrust-api-write'\n }\n }\n req = HTTParty.post('https://localhost/oxauth/restv1/token', params)\n if req.code == 200\n token = req['access_token']\n save_access_token(token, now.to_i + 86_400)\n token\n else\n Puppet.err(\n \"Gluu API HTTP #{req.code}: #{req['error_description']}\",\n )\n end\n end",
"def access_token\n # Synchronization is needed, otherwise race condition may ensue:\n # Let's assume token has expired, and two threads ask for a new token.\n # Both proceed to fetch the token from remote server, both return,\n # but the first token is no longer valid.\n MUTEX.synchronize do\n token = Nordea::Siirto.redis.get(KEY)\n return token if token\n\n Nordea::Siirto.log('Requesting new access token...')\n payload = response.body\n\n token = payload['access_token']\n expires_in = payload['expires_in'] - EXPIRATION_BUFFER\n Nordea::Siirto.redis.set(KEY, token)\n Nordea::Siirto.redis.expire(KEY, expires_in)\n\n token\n end\n end",
"def update_token\n client.authorization.update_token!(oauth_data)\n if client.authorization.refresh_token && client.authorization.expired?\n client.authorization.fetch_access_token!\n end\n end",
"def store_access_token(data)\n @access_token = data['access_token']\n @expires_at = Time.now + data['expires_in']\n end",
"def valid_access_token\n\t\t\t\t# The token we have stored is expired - fetch a new one using the refresh token\n\t\t\t\tself.refresh_access_token if self.access_token_expired?\n\n\t\t\t\tself.access_token\n\t\t\tend",
"def regenerate_auth_token\n new_token = oauth.exchange_access_token_info(authentication.auth_token)\n\n # Save the new token and its expiry over the old one\n authentication.update_attributes!(\n auth_token: new_token['access_token'],\n last_expires_at: authentication.expires_at,\n expires_at: Time.now + new_token['expires_in'].to_i,\n )\n\n authentication.auth_token\n end",
"def access_token\n @access_token ||= ShakeTheCounter::Authentication.renew_access_token(client_id: id, client_secret: secret, refresh_token: refresh_token)[\"access_token\"]\n end",
"def refresh_access_token!\n self.save! if refresh_access_token\n end",
"def refresh(response)\n @access_token = response[:access_token]\n @expires_at = Time.now + response[:expires_in]\n end",
"def get_access_token\n auth = storage['authentication']\n return auth['access_token'] if auth && auth['expires'] > Time.now.to_i\n\n auth = authenticate_client\n storage['authentication'] = auth\n auth['access_token']\n end",
"def refreshed!(body)\n @access_token = body[:access_token]\n @expires_at = Time.now + body[:expires_in]\n end",
"def fetch_access_token! options = {}\n token_hash = fetch_access_token options\n if token_hash\n # No-op for grant types other than `authorization_code`.\n # An authorization code is a one-time use token and is immediately\n # revoked after usage.\n self.code = nil\n self.issued_at = Time.now\n update_token! token_hash\n end\n token_hash\n end",
"def create_token\n client_requested_expires_in = server.jwt['exp'].to_i - server.jwt['iat'].to_i\n server_expires_in = Authorization::Token.access_token_expires_in(configuration, client)\n if server_expires_in\n expires_in = (client_requested_expires_in > 0 && client_requested_expires_in <= server_expires_in) ? client_requested_expires_in : server_expires_in\n else\n expires_in = nil\n end\n @access_token = AccessToken.find_or_create_for(application: client.application, resource_owner: resource_owner, scopes: scopes, expires_in: expires_in, use_refresh_token: configuration.refresh_token_enabled?)\n end",
"def refresh_access_token\n\t\t\t\trequire \"open-uri\"\n\t\t\t\trequire \"net/http\"\n\t\t\t\trequire \"openssl\"\n\t\t\t\trequire \"base64\"\n\n\t\t\t\turi = URI.parse(\"#{self.add_on.jive_url}/oauth2/token\")\n\t\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttp.use_ssl = true\n\n\t\t\t\trequest = Net::HTTP::Post.new(uri.request_uri)\n\t\t\t\trequest.basic_auth self.add_on.client_id, self.add_on.client_secret\n\t\t\t\trequest.set_form_data({\n\t\t\t\t\t\"refresh_token\" => \"#{self.refresh_token}\",\n\t\t\t\t\t\"grant_type\" => \"refresh_token\",\n\t\t\t\t})\n\n\t\t\t\tresponse = http.request(request)\n\t\t\t\tjson_body = JSON.parse(response.body)\n\n\t\t\t\tif (response.code.to_i != 200)\n\t\t\t\t\traise RuntimeError, json_body[\"error\"].to_s.upcase\n\t\t\t\tend\n\n\t\t\t\tself.access_token = json_body[\"access_token\"]\n\t\t\t\tself.expires_in = json_body[\"expires_in\"]\n\t\t\t\tself.expires_at = json_body[\"expires_in\"].to_i.seconds.from_now\n\t\t\t\tself.save\n\t\t\tend",
"def generate_access_token\n begin\n self.access_token = User.new_token\n end while ApiKey.exists?(access_token: access_token)\n end",
"def access_token\n Rails.cache.fetch(\"googl_access_token\", expires_in: 50.minutes) do \n request = { query: { client_id: ENV['GOOGL_CLIENT_ID'],\n client_secret: ENV['GOOGL_CLIENT_SECRET'],\n refresh_token: ENV['GOOGL_REFRESH_TOKEN'],\n grant_type: \"refresh_token\"} }\n\n result = self.class.post(\"/oauth2/v3/token\", request)\n\n result.parsed_response[\"access_token\"]\n end\n end",
"def fetch\n response = request.post(path: \"/#{base_path}/token\", claims_token: claims_token.static)\n\n self.access_token = Oj.load(response.body)['token']\n self\n end",
"def fetch_or_refresh\n refresh_from_store\n fetch_and_write if client.expired?\n client.access_token\n end",
"def set_access_token\n access_tokens.create(token: SecureRandom.urlsafe_base64(20))\n end",
"def refresh(access_token)\n new_access_token = access_token.client.access_token!\n expires = Time.zone.at(decode_id_token(new_access_token.id_token).exp).to_datetime\n\n {\n access_token: new_access_token.access_token,\n expires_at: expires\n }\n rescue Rack::OAuth2::Client::Error\n # Refresh token was expired\n {}\n end",
"def start_expiry_period!\n self.update_attribute(:access_token_expires_at, 2.days.from_now)\n end",
"def create\n require 'digest/sha1'\n \n @access_token = AccessToken.new\n @access_token.user_id = current_user.id\n @access_token.last_access = Time.now\n @access_token.token = Digest::SHA1.hexdigest Time.now.to_s\n @access_token.active = true\n \n respond_to do |format|\n if @access_token.save\n format.html { redirect_to(@access_token, :notice => 'Access token was successfully created.') }\n format.xml { render :xml => @access_token, :status => :created, :location => @access_token }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @access_token.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def refresh_access_token\n return false unless @oauth_access_token.expired?\n\n @oauth_access_token = @oauth_access_token.refresh!\n write_attribute :access_token, @oauth_access_token.token\n write_attribute :access_token_expires_at, @oauth_access_token.expires_at\n true\n end",
"def fresh_hubstaff_access_token\n raise 'Organiaztion not connected to HB. Please edit hubstaff start auth code.' if hubstaff_token_will_end.blank?\n\n # still fresh\n return hubstaff_access_token if hubstaff_token_will_end - 2.hours > DateTime.now\n\n res = HubstaffClient.new.refresh_access_token_request hubstaff_refresh_token\n\n raise StandardError, res.parsed_response['error'] if res.code != 200\n\n self.hubstaff_access_token = res.parsed_response['access_token']\n self.hubstaff_refresh_token = res.parsed_response['refresh_token']\n self.hubstaff_token_get_at = DateTime.now\n self.hubstaff_token_will_end = DateTime.now + (res.parsed_response['expires_in'].to_i / 60.0 / 60.0).round.hours\n\n self.save\n\n hubstaff_access_token\n end",
"def retrieve_token!\n body = request_token\n # Refresh our token early so that it won't expire while a request is in-flight. We expect 15m\n # expirys for tokens but are careful not to trim the expiry by too much, just in case\n expires_in = body['expires_in'].seconds\n if expires_in - AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES > 0\n expires_in -= AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES\n end\n token = \"#{body['token_type']} #{body['access_token']}\"\n Rails.cache.write(AUTH_TOKEN_CACHE_KEY, token, expires_in: expires_in)\n token\n end",
"def refresh! options = {}\n fetch_access_token! options\n end",
"def access_token\n User.create_access_token(self)\n end",
"def refresh!\n response = request_token_from_google\n data = JSON.parse(response.body)\n if data[\"access_token\"].present?\n update_attributes(access_token: data['access_token'], expires_at: Time.now + (data['expires_in'].to_i).seconds)\n else\n puts data[\"error_description\"]\n end\n end",
"def token\n return @access_token if @access_token && !needs_refresh?\n\n update_access_token\n @access_token\n end",
"def refresh_access_token!\n @access_token = access_token.refresh!\n self.class.default_params :access_token => @access_token.token\n @access_token\n end",
"def renew\n req_body = { grant_type: 'refresh_token', refresh_token: @token.refresh_token }\n\n response = JSON.parse(request_token(req_body).body)\n\n @token.update!(response['access_token'], response['expires_in'], response['refresh_token'])\n\n save\n rescue StandardError => e\n puts \"Unable to refresh token\\n#{e.message}\"\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def access_token\n return false unless session[:oauth]\n access_token = OAuth2::AccessToken.from_hash client, session[:oauth].dup\n if access_token.expired?\n access_token = OAuth2::AccessToken.from_hash(client, session[:oauth].dup).refresh!\n session[:oauth] = access_token.to_hash\n end\n @access_token ||= access_token\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token : self.access_token\n end",
"def fetch_tokens(auth_code, save=false)\n\t\t@client ||= api_client()\n @client.authorization.code = auth_code\n @client.authorization.fetch_access_token!\n\n self.refresh_token = @client.authorization.refresh_token\n \tself.access_token = @client.authorization.access_token\n \tself.expires_in = @client.authorization.expires_in\n \tself.issued_at = @client.authorization.issued_at\n\n \tself.save() if save\n\tend",
"def get_access_token\n\t\t\tif @access_token.nil?\n\t\t\t\t# do we have it cached on disk?\n\t\t\t\ttmp_file = get_access_token_file\n\n\t\t\t\tif File.exist? tmp_file\n\t\t\t\t\[email protected] 'Fetching cached auth token from disk'\n\t\t\t\t\tset_access_token(File.read(tmp_file).strip)\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t# try again, get a fresh token\n\t\t\tif @access_token.nil?\n\t\t\t\turi = URI(\"https://#{@club_name}.tidyclub.com/oauth/token\")\n\t\t\t\[email protected] \"Fetching a fresh token from #{uri}\"\n\t\t\t\thttps = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttps.use_ssl = true\n\t\t\t\tpayload = {\n\t\t\t\t\t\tclient_id: client_id,\n\t\t\t\t\t\tclient_secret: client_secret,\n\t\t\t\t\t\tusername: user_name,\n\t\t\t\t\t\tpassword: password,\n\t\t\t\t\t\tgrant_type: 'password'\n\t\t\t\t}\n\t\t\t\trequest = Net::HTTP::Post.new(uri.path)\n\n\t\t\t\trequest.set_form_data payload\n\t\t\t\tresponse = https.request(request)\n\n\t\t\t\tif response.content_type != 'application/json'\n\t\t\t\t\tmsg = \"Expecting a JSON response, got a response type of '#{response.content_type}' instead\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\n\t\t\t\tif response.code.to_i == 200\n\t\t\t\t\tr = JSON.parse response.body\n\t\t\t\t\tset_access_token r['access_token']\n\t\t\t\telse\n\t\t\t\t\tmsg = \"Authentication Failed - response code was: #{response.code} - #{response.message}\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\t\t\tend\n\t\t\t@access_token = nil if @access_token == ''\n\n\t\t\tif @access_token.nil?\n\t\t\t\tmsg = 'There is no valid access token'\n\t\t\t\[email protected] msg\n\t\t\t\traise AuthenticationError, msg\n\t\t\tend\n\n\t\t\t@access_token\n\t\tend",
"def get_new_token\n auth = 'Basic ' + Base64.strict_encode64( session[:client_id] + \":\" + session[:client_secret]).chomp\n \n rcResultJson = RestClient.post(\n session[:token_url],\n {\n grant_type: 'refresh_token', \n refresh_token: session[:refresh_token], \n },\n {\n :Authorization => auth\n }\n )\n rcResult = JSON.parse(rcResultJson)\n\n session[:patient_id] = rcResult[\"patient\"]\n session[:access_token] = rcResult[\"access_token\"]\n session[:refresh_token] = rcResult[\"refresh_token\"]\n session[:token_expiration] = (Time.now.to_i + rcResult[\"expires_in\"].to_i )\n rescue StandardError => exception\n # binding.pry \n err = \"Failed to refresh token: \" + exception.message\n redirect_to root_path, alert: err\n end",
"def generate_access_token\n self.access_token = SecureRandom.hex(64)\n end",
"def renew_access_token!\n @access_token = nil\n true\n end",
"def create_or_renew_token()\n calculate_expiry_time()\n end",
"def refresh_auth_token\n generate_token(:auth_token)\n save!\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def get_new_token\n binding.pry \n auth = 'Basic ' + Base64.strict_encode64( session[:client_id] +\":\"+session[:client_secret]).chomp\n \n rcResultJson = RestClient.post(\n session[:token_url],\n {\n grant_type: 'refresh_token', \n refresh_token: session[:refresh_token], \n },\n {\n :Authorization => auth\n }\n )\n rcResult = JSON.parse(rcResultJson)\n\n session[:patient_id] = rcResult[\"patient\"]\n session[:access_token] = rcResult[\"access_token\"]\n session[:refresh_token] = rcResult[\"refresh_token\"]\n session[:token_expiration] = Time.now.to_i + rcResult[\"expires_in\"].to_i \n rescue => exception\n binding.pry \n err = \"Failed to refresh token\"\n redirect_to root_path, flash: { error: err }\n end",
"def access!\n today = (Time.now.to_i / 3600) * 3600\n if last_access.nil? || last_access < today\n AccessToken.collection.update({ :_id=>token }, { :$set=>{ :last_access=>today, :prev_access=>last_access } })\n self.last_access = today\n end\n end",
"def access!\n today = (Time.now.to_i / 3600) * 3600\n if last_access.nil? || last_access < today\n AccessToken.collection.update({ :_id=>token }, { :$set=>{ :last_access=>today, :prev_access=>last_access } })\n self.last_access = today\n end\n end",
"def sign_access_token\n fetch_access_token() if Time.new.to_i > (@access_token[:expires_at] || 0) + 10\n @access_token[:access_token]\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token! : self.access_token\n end",
"def refresh_access_token!\n @access_token = access_token.refresh!\n end",
"def fetch_access_token\n client.unauthenticated_request(:POST, '/v1/security/oauth2/token',\n grant_type: 'client_credentials',\n client_id: client.client_id,\n client_secret: client.client_secret)\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def get_token\n begin\n @response = RestClient.post(\n @consumer[:token_request_url],\n client_id: @consumer[:client_id],\n client_secret: @consumer[:client_secret],\n grant_type: @consumer[:grant_type],\n resource: @consumer[:resource]\n )\n\n @consumer[:token] = 'Bearer ' + JSON.parse(@response)['access_token']\n @consumer[:token_expiry] = JSON.parse(@response)['expires_on']\n rescue => error\n puts(\"ERROR - Token Request Failed - #{error}\")\n end\n @consumer[:token]\n end",
"def authenticate\n # if valid_access_token?\n # fetch_access_token\n # else\n get_new_access_token\n # end\n end",
"def refresh!\n now = Time.now\n raise RefreshTokenExpired if refresh_token_expires_at&.<= now\n\n data = refresh_token_request!\n\n @access_token = data[\"access_token\"]\n @access_token_expires_at = (now + data[\"expires_in\"])\n\n on_refresh&.call(@access_token, @access_token_expires_at)\n end",
"def access_token\n @access_token ||= OAuth::AccessToken.new(consumer, @token, @secret)\n end",
"def refresh_single_use_oauth2_token!\n assign_single_use_oauth2_token\n save!\n end",
"def init_oauth_access_token\n @oauth_access_token = OAuth2::AccessToken.new(\n User.new_oauth_client,\n read_attribute(:access_token),\n {\n :refresh_token => read_attribute(:refresh_token),\n :expires_at => read_attribute(:access_token_expires_at)\n }\n )\n end",
"def refresh_tokens\n\t\tbegin\n\t\t\t\n\t\t\tresp = $c.initiate_auth({\n\t\t\t auth_flow: \"REFRESH_TOKEN\",\n\t\t\t auth_parameters: {\n\t\t\t \"REFRESH_TOKEN\" => self.refresh_token,\n\t\t\t \"SECRET_HASH\" => calculate_cognito_hmac\n\t\t\t },\n\t\t\t client_id: ENV[\"COGNITO_CLIENT_ID\"]\n\t\t\t})\n\t\t\t\n\t\t\tself.access_token = resp[:authentication_result][:access_token]\n\t\t\tself.refresh_token = resp[:authentication_result][:refresh_token]\n\t\t\tself.token_expires_at = Time.now + (resp[:authentication_result][:expires_in]).seconds\n\t\t\tself.save\n\t\t\t#session[:user] = self\n\t\trescue => e\n\t\t\te.to_s\n\t\tend\t\n\tend",
"def get_access_token\n # Get the current token hash from session\n token_hash = session[:azure_token]\n\n client = OAuth2::Client.new(CLIENT_ID,\n CLIENT_SECRET,\n :site => 'https://login.microsoftonline.com',\n :authorize_url => '/common/oauth2/v2.0/authorize',\n :token_url => '/common/oauth2/v2.0/token')\n\n token = OAuth2::AccessToken.from_hash(client, token_hash)\n\n # Check if token is expired, refresh if so\n if token.expired?\n new_token = token.refresh!\n # Save new token\n session[:azure_token] = new_token.to_hash\n access_token = new_token.token\n else\n access_token = token.token\n end\n end",
"def access_token= new_access_token\n @access_token = new_access_token\n end",
"def get_new_access_token\n client, auth = google_api_client_auth\n print(\"1. Open this page:\\n%s\\n\\n\" % auth.authorization_uri)\n print(\"2. Enter the authorization code shown in the page: \")\n system( 'open \"'+auth.authorization_uri+'\"' )\n auth.code = $stdin.gets.chomp\n auth.fetch_access_token!\n auth.access_token\n end",
"def refresh\n begin\n oauth_attrs = source.create(params: refresh_token_params)\n oauth_attrs.each do |attr, value|\n send(\"#{attr}=\", value)\n end\n rescue My::Oauth::Unauthorized => e\n errors << 'Error refreshing token'\n end\n self\n end",
"def refresh_config_from_access_token\n $LOG.i \"saving access token data in config object\"\n \n @config.access_token = @access_token.token\n @config.refresh_token = @access_token.refresh_token\n @config.expires_in = @access_token.expires_in\n @config.expires_at = @access_token.expires_at\n\n\t$LOG.i \"new config is\", @config\n \n @config\n end",
"def access_token\n @access_token ||= AccessToken.new(caller_service: caller_service, authorizator_service: authorizator_service)\n end",
"def access_token_expires\n return nil unless (temp_access_token_expires = read_attribute(:access_token_expires))\n # logger.debug2 \"temp_access_token_expires = #{temp_access_token_expires}\"\n encrypt_remove_pre_and_postfix(temp_access_token_expires, 'access_token_expires', 44).to_i\n end",
"def access_token_expires\n return nil unless (temp_access_token_expires = read_attribute(:access_token_expires))\n # logger.debug2 \"temp_access_token_expires = #{temp_access_token_expires}\"\n encrypt_remove_pre_and_postfix(temp_access_token_expires, 'access_token_expires', 44).to_i\n end",
"def update_token\n\trequire 'date'\n\ttil = Time.at(settings.exp) - Time.now\n\tleft = (til/60).to_i\n\tp left\n\tif left < 5\n\t\tres = RestClient.post( \"https://auth.exacttargetapis.com/v1/requestToken\",\n\t\t\t\t\t\t\t {\n\t\t\t\t\t\t\t\t:clientId => settings.clientId,\n\t\t\t\t\t\t\t\t:clientSecret => settings.clientSecret,\n\t\t\t\t\t\t\t\t:refreshToken => settings.refreshToken,\n\t\t\t\t\t\t\t\t:accessType => \"offline\"\n\t\t\t\t\t\t\t })\n\t\t@res = JSON.parse(res)\n\t\tsettings.oauthToken = @res[\"accessToken\"]\n\t\tsettings.exp = Time.now + @res[\"expiresIn\"]\n\t\tsettings.refreshToken = @res[\"refreshToken\"]\n\tend\t\nend",
"def generate_access_token\n begin\n self.token = SecureRandom.hex\n end while self.class.exists?(token: token)\n end",
"def generate_access_token\n begin\n self.token = SecureRandom.hex\n end while self.class.exists?(token: token)\n end",
"def regenerate_auth_token!\n generate_auth_token\n set_auth_token_expiry\n\n save\n end",
"def generate_token\n self.status = STATUS[:present]\n self.access_token = SecureRandom.urlsafe_base64(45, true)\n self.expires = Time.zone.now.to_i + TOKEN_LIFE\n self.login_time = Time.zone.now\n self.user_events.build(event_name: 'Login', event_time: Time.zone.now)\n save\n self.access_token\n end",
"def token_refresh!\n self.access_token = access_token.refresh!\n end",
"def valid_token\n access_token = find_or_create_doorkeeper_access_token\n create_doorkeeper_access_token if access_token.expired? || access_token.revoked?\n access_token\n end",
"def access_token\n creds = JSON.parse(File.read(FILE_CREDS))\n authorization = Google::Auth::UserRefreshCredentials.new(\n client_id: creds['installed']['client_id'],\n client_secret: creds['installed']['client_secret'],\n scope: SCOPE,\n refresh_token: refresh_token,\n expires_at: (Time.now+100).utc,\n grant_type: 'authorization_code')\n authorization.fetch_access_token!\n authorization.access_token\nend",
"def access_token\n @access_token ||= begin\n if oauth_options[:oauth_verifier]\n request_token.get_access_token(:oauth_verifier => oauth_options[:oauth_verifier])\n else\n request_token.get_access_token\n end\n end\n end",
"def refresh_token!\n create_token = Kickit::API::CreateToken.new\n resp = create_token.execute(:username => username,\n :developerKey => Kickit::Config.developerKey)\n @token = resp\n end",
"def refreshToken\n # is there a token? (and is it's timestamp not older than 24h?)\n if @token.nil? or @tokenTimeStamp < Time.now - 86400\n @token = getToken(@email,@password)\n @tokenTimeStamp = Time.now\n end\n end",
"def access_token\n @access_token ||= OAuth::AccessToken.new(consumer, @token, @secret)\n end",
"def save\n Rails.cache.write(session_id, token.access_token, namespace: 'check-in-cache', expires_in: 14.minutes)\n end",
"def access_token\n user_token = @user_token\n goat.transaction do\n if user_token.access_token.nil?\n user_token.access_token = request_token.get_access_token\n if !user_token.access_token.nil?\n goat[user_token.user] = user_token\n end\n end\n end\n @user_token = user_token\n @user_token.access_token\n end",
"def authenticate\n Access.new(\n 'access_token' => access_token,\n 'token_type' => token_type,\n 'expires_in' => 1 << (1.size * 8 - 2) - 1 # Max int value\n )\n end",
"def refresh_token()\n if @access_token_obj\n @access_token_obj.refresh_token\n else\n return nil\n end\n end",
"def refresh_oauth2_token!\n ensure_oauth2_token(true)\n save!\n end",
"def call\n api_key = ApiKey.find_by(access_token: @expired_token)\n\n if api_key.present?\n api_key.refresh\n api_key.save\n\n {\n token: api_key.access_token\n }\n else\n raise ExceptionService.new('Invalid Token.')\n end\n end",
"def acquire_token()\n response_body = JSON.load(`#{cli_path} account get-access-token -o json --resource #{@settings.token_audience}`)\n \n @token_expires_on = Time.parse(response_body['expiresOn'])\n @token_type = response_body['tokenType']\n @token = response_body['accessToken']\n rescue\n raise AzureCliError, 'Error acquiring token from the Azure CLI'\n end",
"def access_token\n OAuth::AccessToken.new(consumer, oauth_token, oauth_token_secret)\n end"
] | [
"0.7862805",
"0.78125745",
"0.78091955",
"0.77942175",
"0.77459115",
"0.7533844",
"0.75099",
"0.75034916",
"0.7409117",
"0.73745674",
"0.73525053",
"0.733773",
"0.73235583",
"0.73169035",
"0.7205781",
"0.7152392",
"0.7148212",
"0.71401495",
"0.71336514",
"0.7132626",
"0.7122158",
"0.7082551",
"0.70665044",
"0.7047365",
"0.70062834",
"0.69944227",
"0.69870734",
"0.6970561",
"0.6945486",
"0.68891555",
"0.6855235",
"0.68289775",
"0.6824332",
"0.68161356",
"0.681235",
"0.6796928",
"0.6793669",
"0.6788312",
"0.67759055",
"0.6759656",
"0.6738924",
"0.6738924",
"0.6738924",
"0.6734606",
"0.6716193",
"0.6710728",
"0.6709831",
"0.6708545",
"0.670698",
"0.67040753",
"0.6700588",
"0.66929287",
"0.6692865",
"0.6692865",
"0.6692865",
"0.6692865",
"0.6680512",
"0.6674334",
"0.6674334",
"0.6670781",
"0.6664893",
"0.66612923",
"0.6636455",
"0.66363895",
"0.66363895",
"0.66361076",
"0.6629878",
"0.6585118",
"0.6581689",
"0.6570658",
"0.6566276",
"0.6559454",
"0.6558424",
"0.65427715",
"0.65396225",
"0.6538988",
"0.6536479",
"0.6530725",
"0.6526951",
"0.6526951",
"0.65268725",
"0.65161574",
"0.65161574",
"0.6512413",
"0.65116024",
"0.6508334",
"0.65053374",
"0.6501236",
"0.64905983",
"0.64904666",
"0.6489944",
"0.64878786",
"0.64858866",
"0.6471397",
"0.64700484",
"0.6467766",
"0.6453007",
"0.6450038",
"0.64431626",
"0.64336497"
] | 0.76162064 | 5 |
Fetches a new access token | def fetch_access_token
client.unauthenticated_request(:POST, '/v1/security/oauth2/token',
grant_type: 'client_credentials',
client_id: client.client_id,
client_secret: client.client_secret)
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fresh_token\n refresh! if token_expired?\n access_token\n end",
"def update_token\n client.authorization.update_token!(oauth_data)\n if client.authorization.refresh_token && client.authorization.expired?\n client.authorization.fetch_access_token!\n end\n end",
"def fresh_token\n refresh! if expired?\n access_token\n end",
"def update_access_token\n response = fetch_access_token\n store_access_token(response.result)\n end",
"def access_token\n refresh! if access_token_expires_at&.<= Time.now + 60 # time drift margin\n @access_token\n end",
"def fetch_access_token! options = {}\n token_hash = fetch_access_token options\n if token_hash\n # No-op for grant types other than `authorization_code`.\n # An authorization code is a one-time use token and is immediately\n # revoked after usage.\n self.code = nil\n self.issued_at = Time.now\n update_token! token_hash\n end\n token_hash\n end",
"def get_new_access_token\n client, auth = google_api_client_auth\n print(\"1. Open this page:\\n%s\\n\\n\" % auth.authorization_uri)\n print(\"2. Enter the authorization code shown in the page: \")\n system( 'open \"'+auth.authorization_uri+'\"' )\n auth.code = $stdin.gets.chomp\n auth.fetch_access_token!\n auth.access_token\n end",
"def generate_access_token\n self.access_token ||= self.create_access_token\n save && access_token\n end",
"def access_token\n # Fetch from cache. We can expect this to be `nil` if unset or expired.\n #\n access_token = read_cache\n\n return access_token if access_token\n\n fetch_new_access_token\n end",
"def get_new_access_token\n now = Time.now\n params = {\n body: {\n grant_type: 'urn:ietf:params:oauth:grant-type:uma-ticket',\n ticket: retrieve_ticket,\n client_id: key_info['oxtrust_client_id'],\n client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n client_assertion: generate_json_web_token(now),\n scope: 'oxtrust-api-read oxtrust-api-write'\n }\n }\n req = HTTParty.post('https://localhost/oxauth/restv1/token', params)\n if req.code == 200\n token = req['access_token']\n save_access_token(token, now.to_i + 86_400)\n token\n else\n Puppet.err(\n \"Gluu API HTTP #{req.code}: #{req['error_description']}\",\n )\n end\n end",
"def refresh! options = {}\n fetch_access_token! options\n end",
"def generate_access_token\n begin\n self.access_token = User.new_token\n end while ApiKey.exists?(access_token: access_token)\n end",
"def access_token\n @access_token ||= ShakeTheCounter::Authentication.renew_access_token(client_id: id, client_secret: secret, refresh_token: refresh_token)[\"access_token\"]\n end",
"def access_token\n # Synchronization is needed, otherwise race condition may ensue:\n # Let's assume token has expired, and two threads ask for a new token.\n # Both proceed to fetch the token from remote server, both return,\n # but the first token is no longer valid.\n MUTEX.synchronize do\n token = Nordea::Siirto.redis.get(KEY)\n return token if token\n\n Nordea::Siirto.log('Requesting new access token...')\n payload = response.body\n\n token = payload['access_token']\n expires_in = payload['expires_in'] - EXPIRATION_BUFFER\n Nordea::Siirto.redis.set(KEY, token)\n Nordea::Siirto.redis.expire(KEY, expires_in)\n\n token\n end\n end",
"def fetch\n response = request.post(path: \"/#{base_path}/token\", claims_token: claims_token.static)\n\n self.access_token = Oj.load(response.body)['token']\n self\n end",
"def refresh_access_token\n new_token = FireCloudClient.generate_access_token(self.service_account_credentials)\n new_expiry = Time.zone.now + new_token['expires_in']\n self.access_token = new_token\n self.expires_at = new_expiry\n new_token\n end",
"def refresh_access_token()\n\n\t\tif(Time.now - @start_time) >=3000\n\t\t\tputs \"Access Token Expired .......Creating a new one\"\n\t\t\t@access_token = @new_token.get_access_token\n\t\t\t@start_time = Time.now\n\t\tend\n\tend",
"def authenticate\n # if valid_access_token?\n # fetch_access_token\n # else\n get_new_access_token\n # end\n end",
"def access_token\n Rails.cache.fetch(\"googl_access_token\", expires_in: 50.minutes) do \n request = { query: { client_id: ENV['GOOGL_CLIENT_ID'],\n client_secret: ENV['GOOGL_CLIENT_SECRET'],\n refresh_token: ENV['GOOGL_REFRESH_TOKEN'],\n grant_type: \"refresh_token\"} }\n\n result = self.class.post(\"/oauth2/v3/token\", request)\n\n result.parsed_response[\"access_token\"]\n end\n end",
"def refresh_access_token!\n self.save! if refresh_access_token\n end",
"def fetch_or_refresh\n refresh_from_store\n fetch_and_write if client.expired?\n client.access_token\n end",
"def refresh_access_token!\n @access_token = access_token.refresh!\n self.class.default_params :access_token => @access_token.token\n @access_token\n end",
"def refresh_access_token\n self.expires_at = Time.now + 3600 \n save\n end",
"def refresh_access_token!\n @access_token = access_token.refresh!\n end",
"def refresh_access_token\n\t\t\t\trequire \"open-uri\"\n\t\t\t\trequire \"net/http\"\n\t\t\t\trequire \"openssl\"\n\t\t\t\trequire \"base64\"\n\n\t\t\t\turi = URI.parse(\"#{self.add_on.jive_url}/oauth2/token\")\n\t\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttp.use_ssl = true\n\n\t\t\t\trequest = Net::HTTP::Post.new(uri.request_uri)\n\t\t\t\trequest.basic_auth self.add_on.client_id, self.add_on.client_secret\n\t\t\t\trequest.set_form_data({\n\t\t\t\t\t\"refresh_token\" => \"#{self.refresh_token}\",\n\t\t\t\t\t\"grant_type\" => \"refresh_token\",\n\t\t\t\t})\n\n\t\t\t\tresponse = http.request(request)\n\t\t\t\tjson_body = JSON.parse(response.body)\n\n\t\t\t\tif (response.code.to_i != 200)\n\t\t\t\t\traise RuntimeError, json_body[\"error\"].to_s.upcase\n\t\t\t\tend\n\n\t\t\t\tself.access_token = json_body[\"access_token\"]\n\t\t\t\tself.expires_in = json_body[\"expires_in\"]\n\t\t\t\tself.expires_at = json_body[\"expires_in\"].to_i.seconds.from_now\n\t\t\t\tself.save\n\t\t\tend",
"def get_access_token\n raise HyvesException, 'You need an request token to make get an access token' if request_token.nil?\n @access_token = request_token.get_access_token\n\n @userid = request_token.response[\"userid\"]\n @expiredate = Time.at(request_token.response[\"expiredate\"].to_i) if not request_token.response[\"expiredate\"].nil?\n\n @access_token\n end",
"def refresh(access_token)\n new_access_token = access_token.client.access_token!\n expires = Time.zone.at(decode_id_token(new_access_token.id_token).exp).to_datetime\n\n {\n access_token: new_access_token.access_token,\n expires_at: expires\n }\n rescue Rack::OAuth2::Client::Error\n # Refresh token was expired\n {}\n end",
"def token\n return @access_token if @access_token && !needs_refresh?\n\n update_access_token\n @access_token\n end",
"def valid_access_token\n\t\t\t\t# The token we have stored is expired - fetch a new one using the refresh token\n\t\t\t\tself.refresh_access_token if self.access_token_expired?\n\n\t\t\t\tself.access_token\n\t\t\tend",
"def refresh_single_use_oauth2_token!\n assign_single_use_oauth2_token\n save!\n end",
"def find_oauth_access_token\n end",
"def fetch_access_token\n uri = URI.parse Sendible::API::URL + \"/v1/auth?app_id=#{CGI.escape(Sendible.application_id)}&access_key=#{CGI.escape(access_key)}\"\n get = Net::HTTP::Get.new(uri.request_uri)\n response = Net::HTTP.start(uri.host, uri.port) do |http|\n http.request(get)\n end\n response.body\n end",
"def access_token\n User.create_access_token(self)\n end",
"def get_token\n begin\n @response = RestClient.post(\n @consumer[:token_request_url],\n client_id: @consumer[:client_id],\n client_secret: @consumer[:client_secret],\n grant_type: @consumer[:grant_type],\n resource: @consumer[:resource]\n )\n\n @consumer[:token] = 'Bearer ' + JSON.parse(@response)['access_token']\n @consumer[:token_expiry] = JSON.parse(@response)['expires_on']\n rescue => error\n puts(\"ERROR - Token Request Failed - #{error}\")\n end\n @consumer[:token]\n end",
"def access_token\n creds = JSON.parse(File.read(FILE_CREDS))\n authorization = Google::Auth::UserRefreshCredentials.new(\n client_id: creds['installed']['client_id'],\n client_secret: creds['installed']['client_secret'],\n scope: SCOPE,\n refresh_token: refresh_token,\n expires_at: (Time.now+100).utc,\n grant_type: 'authorization_code')\n authorization.fetch_access_token!\n authorization.access_token\nend",
"def get_access_token(authz_code = nil)\n if @config.grant_type == 'client_credentials'\n $LOG.i \"getting access token\"\n\t @access_token = @oauth2_client.client_credentials.get_token\n $LOG.i \"got access token\", @access_token\n else\n $LOG.i \"getting access and refresh token pair\"\n\t @access_token = @oauth2_client.auth_code.get_token(authz_code, :redirect_uri => @config.redirect_uri)\n $LOG.i \"got access and refresh token pair\", @access_token\n end\n\n\trefresh_config_from_access_token\n\n\t@access_token\n end",
"def token_refresh!\n self.access_token = access_token.refresh!\n end",
"def get_access_token\n auth = storage['authentication']\n return auth['access_token'] if auth && auth['expires'] > Time.now.to_i\n\n auth = authenticate_client\n storage['authentication'] = auth\n auth['access_token']\n end",
"def refresh_access_token(refresh_token = @config.REFRESH_TOKEN)\r\n get_new_access_token(refresh_token)\r\n end",
"def access_token\n @access_token ||= begin\n if oauth_options[:oauth_verifier]\n request_token.get_access_token(:oauth_verifier => oauth_options[:oauth_verifier])\n else\n request_token.get_access_token\n end\n end\n end",
"def get_new_token\n auth = 'Basic ' + Base64.strict_encode64( session[:client_id] + \":\" + session[:client_secret]).chomp\n \n rcResultJson = RestClient.post(\n session[:token_url],\n {\n grant_type: 'refresh_token', \n refresh_token: session[:refresh_token], \n },\n {\n :Authorization => auth\n }\n )\n rcResult = JSON.parse(rcResultJson)\n\n session[:patient_id] = rcResult[\"patient\"]\n session[:access_token] = rcResult[\"access_token\"]\n session[:refresh_token] = rcResult[\"refresh_token\"]\n session[:token_expiration] = (Time.now.to_i + rcResult[\"expires_in\"].to_i )\n rescue StandardError => exception\n # binding.pry \n err = \"Failed to refresh token: \" + exception.message\n redirect_to root_path, alert: err\n end",
"def get_new_token\n binding.pry \n auth = 'Basic ' + Base64.strict_encode64( session[:client_id] +\":\"+session[:client_secret]).chomp\n \n rcResultJson = RestClient.post(\n session[:token_url],\n {\n grant_type: 'refresh_token', \n refresh_token: session[:refresh_token], \n },\n {\n :Authorization => auth\n }\n )\n rcResult = JSON.parse(rcResultJson)\n\n session[:patient_id] = rcResult[\"patient\"]\n session[:access_token] = rcResult[\"access_token\"]\n session[:refresh_token] = rcResult[\"refresh_token\"]\n session[:token_expiration] = Time.now.to_i + rcResult[\"expires_in\"].to_i \n rescue => exception\n binding.pry \n err = \"Failed to refresh token\"\n redirect_to root_path, flash: { error: err }\n end",
"def refresh!\n response = request_token_from_google\n data = JSON.parse(response.body)\n if data[\"access_token\"].present?\n update_attributes(access_token: data['access_token'], expires_at: Time.now + (data['expires_in'].to_i).seconds)\n else\n puts data[\"error_description\"]\n end\n end",
"def fetch_tokens(auth_code, save=false)\n\t\t@client ||= api_client()\n @client.authorization.code = auth_code\n @client.authorization.fetch_access_token!\n\n self.refresh_token = @client.authorization.refresh_token\n \tself.access_token = @client.authorization.access_token\n \tself.expires_in = @client.authorization.expires_in\n \tself.issued_at = @client.authorization.issued_at\n\n \tself.save() if save\n\tend",
"def access_token\n end",
"def retrieve_token!\n body = request_token\n # Refresh our token early so that it won't expire while a request is in-flight. We expect 15m\n # expirys for tokens but are careful not to trim the expiry by too much, just in case\n expires_in = body['expires_in'].seconds\n if expires_in - AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES > 0\n expires_in -= AUTH_TOKEN_PREEMPTIVE_EXPIRY_MINUTES\n end\n token = \"#{body['token_type']} #{body['access_token']}\"\n Rails.cache.write(AUTH_TOKEN_CACHE_KEY, token, expires_in: expires_in)\n token\n end",
"def refresh!(params = {})\n raise('A refresh_token is not available') unless refresh_token\n params[:grant_type] = 'refresh_token'\n params[:refresh_token] = refresh_token\n new_token = @client.get_token(params)\n new_token.options = options\n new_token.refresh_token = refresh_token unless new_token.refresh_token\n new_token\n end",
"def acquire_token()\n response_body = JSON.load(`#{cli_path} account get-access-token -o json --resource #{@settings.token_audience}`)\n \n @token_expires_on = Time.parse(response_body['expiresOn'])\n @token_type = response_body['tokenType']\n @token = response_body['accessToken']\n rescue\n raise AzureCliError, 'Error acquiring token from the Azure CLI'\n end",
"def refresh_token()\n if @access_token_obj\n @access_token_obj.refresh_token\n else\n return nil\n end\n end",
"def get_access_token()\n url = URI.parse(TOKEN_ENDPOINT)\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n req = Net::HTTP::Post.new(url.path)\n req.basic_auth(@clientId, @clientSecret)\n req.set_form_data({'grant_type' => 'client_credentials'})\n res = http.request(req)\n JSON.parse(res.body)['access_token']\n end",
"def get_access_token\n # Get the current token hash from session\n token_hash = session[:azure_token]\n\n client = OAuth2::Client.new(CLIENT_ID,\n CLIENT_SECRET,\n :site => 'https://login.microsoftonline.com',\n :authorize_url => '/common/oauth2/v2.0/authorize',\n :token_url => '/common/oauth2/v2.0/token')\n\n token = OAuth2::AccessToken.from_hash(client, token_hash)\n\n # Check if token is expired, refresh if so\n if token.expired?\n new_token = token.refresh!\n # Save new token\n session[:azure_token] = new_token.to_hash\n access_token = new_token.token\n else\n access_token = token.token\n end\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def generate_access_token\n begin\n self.access_token = SecureRandom.hex\n end while self.class.exists?(access_token: access_token)\n end",
"def access_token= new_access_token\n @access_token = new_access_token\n end",
"def refresh_token\n @token = @authenticator.refresh_token\n end",
"def refresh_token!\n create_token = Kickit::API::CreateToken.new\n resp = create_token.execute(:username => username,\n :developerKey => Kickit::Config.developerKey)\n @token = resp\n end",
"def get_access_token! name = nil\n oauth_instance(name).get_access_token!(oauth_request_env)\n end",
"def refresh_auth_token\n generate_token(:auth_token)\n save!\n end",
"def get_access_token\n\t\t\tif @access_token.nil?\n\t\t\t\t# do we have it cached on disk?\n\t\t\t\ttmp_file = get_access_token_file\n\n\t\t\t\tif File.exist? tmp_file\n\t\t\t\t\[email protected] 'Fetching cached auth token from disk'\n\t\t\t\t\tset_access_token(File.read(tmp_file).strip)\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t# try again, get a fresh token\n\t\t\tif @access_token.nil?\n\t\t\t\turi = URI(\"https://#{@club_name}.tidyclub.com/oauth/token\")\n\t\t\t\[email protected] \"Fetching a fresh token from #{uri}\"\n\t\t\t\thttps = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttps.use_ssl = true\n\t\t\t\tpayload = {\n\t\t\t\t\t\tclient_id: client_id,\n\t\t\t\t\t\tclient_secret: client_secret,\n\t\t\t\t\t\tusername: user_name,\n\t\t\t\t\t\tpassword: password,\n\t\t\t\t\t\tgrant_type: 'password'\n\t\t\t\t}\n\t\t\t\trequest = Net::HTTP::Post.new(uri.path)\n\n\t\t\t\trequest.set_form_data payload\n\t\t\t\tresponse = https.request(request)\n\n\t\t\t\tif response.content_type != 'application/json'\n\t\t\t\t\tmsg = \"Expecting a JSON response, got a response type of '#{response.content_type}' instead\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\n\t\t\t\tif response.code.to_i == 200\n\t\t\t\t\tr = JSON.parse response.body\n\t\t\t\t\tset_access_token r['access_token']\n\t\t\t\telse\n\t\t\t\t\tmsg = \"Authentication Failed - response code was: #{response.code} - #{response.message}\"\n\t\t\t\t\[email protected] msg\n\t\t\t\t\traise TidyClub::ApiCallBad, msg\n\t\t\t\tend\n\t\t\tend\n\t\t\t@access_token = nil if @access_token == ''\n\n\t\t\tif @access_token.nil?\n\t\t\t\tmsg = 'There is no valid access token'\n\t\t\t\[email protected] msg\n\t\t\t\traise AuthenticationError, msg\n\t\t\tend\n\n\t\t\t@access_token\n\t\tend",
"def access_token; self; end",
"def refresh(response)\n @access_token = response[:access_token]\n @expires_at = Time.now + response[:expires_in]\n end",
"def retrieve_token\n puts \"Picking up new token.\"\n parsed_json = {}\n until parsed_json[\"access_token\"]\n results = `curl -X -vvv -d 'client_id=MY_CLIENT_KEY&client_secret=MY_CLIENT_SECRET&grant_type=client_credentials' -X POST 'https://connect.gettyimages.com/oauth2/token/'`\n parsed_json = JSON.parse results\n end\n @token = parsed_json[\"access_token\"]\n end",
"def get_access_token(options={})\n response=consumer.token_request(consumer.http_method,(consumer.access_token_url? ? consumer.access_token_url : consumer.access_token_path),self,options)\n OAuth::AccessToken.new(consumer,response[:oauth_token],response[:oauth_token_secret])\n end",
"def access_token\n @access_token ||= OAuth::AccessToken.new(consumer, @token, @secret)\n end",
"def update_token\n params = {\n client_id: client_id,\n client_secret: client_secret,\n grant_type: 'refresh_token',\n refresh_token: refresh_token\n }\n request(:post, 'oauth2/token', params, true)\n end",
"def get_access_token\n uri = URI.parse(@token_url)\n http = Net::HTTP.new(uri.host, uri.port)\n req = Net::HTTP::Post.new(uri.request_uri)\n auth = Base64.encode64(@login + ':' + @password).gsub(\"\\n\", \"\")\n req['Authorization'] = \"Basic #{auth}\"\n send = 'grant_type=client_credentials'\n req.body = send\n res = http.request(req)\n if res.code == \"200\"\n data = res.body\n result = JSON.parse(data)\n @access_token = result['access_token']\n else\n puts \"Invalid getting access token\"\n exit\n end\n end",
"def fetch_token_from_hash(refresh_token)\n @access_token_obj = OAuth2::AccessToken.from_hash(@auth_client,\n :refresh_token => refresh_token).refresh!\n end",
"def get_access_token\n\t\treturn @credentials.get_access_token\n\tend",
"def set_access_token\n access_tokens.create(token: SecureRandom.urlsafe_base64(20))\n end",
"def refresh_oauth2_token!\n ensure_oauth2_token(true)\n save!\n end",
"def access_token\n OAuth::AccessToken.new(consumer, oauth_token, oauth_token_secret)\n end",
"def build_token(access_token)\n return OAuth2::AccessToken.new CLIENT, access_token\n end",
"def get_access_token name = nil\n oauth_instance(name).get_access_token(oauth_request_env)\n end",
"def regenerate_auth_token\n new_token = oauth.exchange_access_token_info(authentication.auth_token)\n\n # Save the new token and its expiry over the old one\n authentication.update_attributes!(\n auth_token: new_token['access_token'],\n last_expires_at: authentication.expires_at,\n expires_at: Time.now + new_token['expires_in'].to_i,\n )\n\n authentication.auth_token\n end",
"def refresh\n begin\n oauth_attrs = source.create(params: refresh_token_params)\n oauth_attrs.each do |attr, value|\n send(\"#{attr}=\", value)\n end\n rescue My::Oauth::Unauthorized => e\n errors << 'Error refreshing token'\n end\n self\n end",
"def generate_access_token\n begin\n self.token = SecureRandom.hex\n end while self.class.exists?(token: token)\n end",
"def generate_access_token\n begin\n self.token = SecureRandom.hex\n end while self.class.exists?(token: token)\n end",
"def token\n @token ||= Rails.cache.fetch('osu_api_token', expires_in: 23.hours) do\n logger.debug(\"Fetching new OAuth2 Token from OSU API : #{@url}\")\n json = post(url_encoded_connection,\n ENV.fetch(OSU_API_OAUTH2_TOKEN),\n client_id: @key,\n client_secret: @secret,\n grant_type: 'client_credentials')\n json['access_token']\n end\n end",
"def access_token\n @access_token ||= AccessToken.new(caller_service: caller_service, authorizator_service: authorizator_service)\n end",
"def refresh_token\n self.generate_token\n end",
"def access_token\n return false unless session[:oauth]\n access_token = OAuth2::AccessToken.from_hash client, session[:oauth].dup\n if access_token.expired?\n access_token = OAuth2::AccessToken.from_hash(client, session[:oauth].dup).refresh!\n session[:oauth] = access_token.to_hash\n end\n @access_token ||= access_token\n end",
"def refreshed!(body)\n @access_token = body[:access_token]\n @expires_at = Time.now + body[:expires_in]\n end",
"def create\n client.authorization_code = params[:code]\n access_token = client.access_token!\n puts access_token\n end",
"def access_token\n @access_token ||= nil\n end",
"def access_token\n @access_token ||= OAuth::AccessToken.new(consumer, @token, @secret)\n end",
"def get_access_token(auth_code)\n @access_token = @oauth_client.auth_code.get_token(auth_code, :redirect_uri => @redirect_uri)\n @token = @access_token.token\n @refresh_token = @access_token.refresh_token\n @token_expires_at = @access_token.expires_at\n end",
"def refresh_access!\n response = auth_connection.post(\n \"/api/v1/access_token\",\n grant_type: \"refresh_token\",\n refresh_token: access.refresh_token\n )\n access.refreshed!(response.body)\n reset_connection!\n end",
"def generate_access_token\n self.access_token = SecureRandom.hex(64)\n end",
"def refresh_token(token = @token)\n raise \"invalid token\" unless token\n @access_token ||= OAuth2::AccessToken.new(@oauth_client, token, :refresh_token => @refresh_token, :expires_at => @token_expires_at)\n if @access_token.expired?\n @access_token.refresh!\n @access_token_refreshed = true\n end\n end",
"def refresh_access_token(access_token)\n begin\n client, auth = google_api_client_auth\n auth.refresh_token = access_token\n auth.refresh!\n auth.access_token\n rescue\n puts \"Failed to refresh Google OAuth access token\"\n nil\n end\n end",
"def refresh_tokens\n\t\tbegin\n\t\t\t\n\t\t\tresp = $c.initiate_auth({\n\t\t\t auth_flow: \"REFRESH_TOKEN\",\n\t\t\t auth_parameters: {\n\t\t\t \"REFRESH_TOKEN\" => self.refresh_token,\n\t\t\t \"SECRET_HASH\" => calculate_cognito_hmac\n\t\t\t },\n\t\t\t client_id: ENV[\"COGNITO_CLIENT_ID\"]\n\t\t\t})\n\t\t\t\n\t\t\tself.access_token = resp[:authentication_result][:access_token]\n\t\t\tself.refresh_token = resp[:authentication_result][:refresh_token]\n\t\t\tself.token_expires_at = Time.now + (resp[:authentication_result][:expires_in]).seconds\n\t\t\tself.save\n\t\t\t#session[:user] = self\n\t\trescue => e\n\t\t\te.to_s\n\t\tend\t\n\tend",
"def renew_access_token!\n @access_token = nil\n true\n end",
"def refresh_access_token\n return false unless @oauth_access_token.expired?\n\n @oauth_access_token = @oauth_access_token.refresh!\n write_attribute :access_token, @oauth_access_token.token\n write_attribute :access_token_expires_at, @oauth_access_token.expires_at\n true\n end",
"def create\n require 'digest/sha1'\n \n @access_token = AccessToken.new\n @access_token.user_id = current_user.id\n @access_token.last_access = Time.now\n @access_token.token = Digest::SHA1.hexdigest Time.now.to_s\n @access_token.active = true\n \n respond_to do |format|\n if @access_token.save\n format.html { redirect_to(@access_token, :notice => 'Access token was successfully created.') }\n format.xml { render :xml => @access_token, :status => :created, :location => @access_token }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @access_token.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def access_token\n @auth.access_token\n end",
"def renew_token\n body_params = token_request_body\n body_params << [\"refresh_token\", current_user.refresh_token]\n body_params << [\"grant_type\", \"refresh_token\"]\n\n get_token(body_params)\n redirect_to sage_accounting_data_path\n end",
"def access_token\n user_token = @user_token\n goat.transaction do\n if user_token.access_token.nil?\n user_token.access_token = request_token.get_access_token\n if !user_token.access_token.nil?\n goat[user_token.user] = user_token\n end\n end\n end\n @user_token = user_token\n @user_token.access_token\n end",
"def fetch\n Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|\n req = Net::HTTP::Post.new(url)\n req[\"Accept\"] = \"application/json\"\n data = {\n \"client_id\" => client_id,\n \"client_secret\" => client_secret,\n \"grant_type\" => \"client_credentials\",\n \"scope\" => \"/read-public\"\n }\n req.set_form_data(data)\n body = http.request(req).body\n JSON.parse(body)[\"access_token\"]\n end\n end"
] | [
"0.77791345",
"0.7716003",
"0.7706114",
"0.76284635",
"0.76284397",
"0.7589101",
"0.7462341",
"0.7450183",
"0.7437448",
"0.7434031",
"0.74107265",
"0.7403465",
"0.7371638",
"0.7363965",
"0.7320902",
"0.7306013",
"0.72838026",
"0.72780585",
"0.7252591",
"0.72446483",
"0.7224897",
"0.71969897",
"0.71697176",
"0.7144103",
"0.71163005",
"0.71146923",
"0.7080858",
"0.7064187",
"0.7030921",
"0.70009154",
"0.6989717",
"0.69782203",
"0.6976746",
"0.6967808",
"0.6952265",
"0.6921123",
"0.69190097",
"0.6917078",
"0.69131655",
"0.68987584",
"0.68983674",
"0.6889314",
"0.68461436",
"0.6845733",
"0.68399334",
"0.6831561",
"0.6827388",
"0.6824808",
"0.68232375",
"0.681803",
"0.6815889",
"0.6815633",
"0.6815633",
"0.6815633",
"0.6815633",
"0.6798366",
"0.67828465",
"0.67807215",
"0.6780152",
"0.67781055",
"0.6762477",
"0.6756431",
"0.67385477",
"0.67371964",
"0.6736318",
"0.67322206",
"0.67308795",
"0.67298704",
"0.6729819",
"0.6726668",
"0.6714672",
"0.6707644",
"0.670142",
"0.6696475",
"0.6692189",
"0.66865355",
"0.6684081",
"0.6671454",
"0.6671454",
"0.6666089",
"0.6659257",
"0.6657644",
"0.6656845",
"0.6651794",
"0.66442347",
"0.663773",
"0.6637426",
"0.66326404",
"0.663236",
"0.66198486",
"0.661373",
"0.66069734",
"0.6604994",
"0.6601172",
"0.6591668",
"0.6591383",
"0.65890545",
"0.65816057",
"0.6577299",
"0.65744317"
] | 0.74952424 | 6 |
Store an access token and calculates the expiry date | def store_access_token(data)
@access_token = data['access_token']
@expires_at = Time.now + data['expires_in']
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh_access_token\n self.expires_at = Time.now + 3600 \n save\n end",
"def access_token_expires\n return nil unless (temp_access_token_expires = read_attribute(:access_token_expires))\n # logger.debug2 \"temp_access_token_expires = #{temp_access_token_expires}\"\n encrypt_remove_pre_and_postfix(temp_access_token_expires, 'access_token_expires', 44).to_i\n end",
"def access_token_expires\n return nil unless (temp_access_token_expires = read_attribute(:access_token_expires))\n # logger.debug2 \"temp_access_token_expires = #{temp_access_token_expires}\"\n encrypt_remove_pre_and_postfix(temp_access_token_expires, 'access_token_expires', 44).to_i\n end",
"def access_token\n refresh! if access_token_expires_at&.<= Time.now + 60 # time drift margin\n @access_token\n end",
"def start_expiry_period!\n self.update_attribute(:access_token_expires_at, 2.days.from_now)\n end",
"def refresh_access_token\n new_token = FireCloudClient.generate_access_token(self.service_account_credentials)\n new_expiry = Time.zone.now + new_token['expires_in']\n self.access_token = new_token\n self.expires_at = new_expiry\n new_token\n end",
"def update_access_token\n response = fetch_access_token\n store_access_token(response.result)\n end",
"def create_or_renew_token()\n calculate_expiry_time()\n end",
"def store_access_token(access_token_id, user_id)\n @redis.set(auth_domain_key(access_token_id), user_id)\n @redis.expire(auth_domain_key(access_token_id), @access_token_lifetime)\n end",
"def set_auth_token_expiry\n self.auth_token_expires_at = (Time.zone.now + 30.days)\n end",
"def save\n Rails.cache.write(session_id, token.access_token, namespace: 'check-in-cache', expires_in: 14.minutes)\n end",
"def sign_access_token\n fetch_access_token() if Time.new.to_i > (@access_token[:expires_at] || 0) + 10\n @access_token[:access_token]\n end",
"def set_access_token\n access_tokens.create(token: SecureRandom.urlsafe_base64(20))\n end",
"def refresh_access_token()\n\n\t\tif(Time.now - @start_time) >=3000\n\t\t\tputs \"Access Token Expired .......Creating a new one\"\n\t\t\t@access_token = @new_token.get_access_token\n\t\t\t@start_time = Time.now\n\t\tend\n\tend",
"def generate_access_token\n self.access_token ||= self.create_access_token\n save && access_token\n end",
"def set_token_expires_at\n self.token_expires_at = 3600.seconds.from_now\n end",
"def start_expiry_period!\n self.update_attribute(:access_token_expires_at, Time.now + Devise.timeout_in)\n end",
"def create_token\n client_requested_expires_in = server.jwt['exp'].to_i - server.jwt['iat'].to_i\n server_expires_in = Authorization::Token.access_token_expires_in(configuration, client)\n if server_expires_in\n expires_in = (client_requested_expires_in > 0 && client_requested_expires_in <= server_expires_in) ? client_requested_expires_in : server_expires_in\n else\n expires_in = nil\n end\n @access_token = AccessToken.find_or_create_for(application: client.application, resource_owner: resource_owner, scopes: scopes, expires_in: expires_in, use_refresh_token: configuration.refresh_token_enabled?)\n end",
"def access!\n today = (Time.now.to_i / 3600) * 3600\n if last_access.nil? || last_access < today\n AccessToken.collection.update({ :_id=>token }, { :$set=>{ :last_access=>today, :prev_access=>last_access } })\n self.last_access = today\n end\n end",
"def access!\n today = (Time.now.to_i / 3600) * 3600\n if last_access.nil? || last_access < today\n AccessToken.collection.update({ :_id=>token }, { :$set=>{ :last_access=>today, :prev_access=>last_access } })\n self.last_access = today\n end\n end",
"def refreshed!(body)\n @access_token = body[:access_token]\n @expires_at = Time.now + body[:expires_in]\n end",
"def valid_access_token\n\t\t\t\t# The token we have stored is expired - fetch a new one using the refresh token\n\t\t\t\tself.refresh_access_token if self.access_token_expired?\n\n\t\t\t\tself.access_token\n\t\t\tend",
"def get_access_token\n raise HyvesException, 'You need an request token to make get an access token' if request_token.nil?\n @access_token = request_token.get_access_token\n\n @userid = request_token.response[\"userid\"]\n @expiredate = Time.at(request_token.response[\"expiredate\"].to_i) if not request_token.response[\"expiredate\"].nil?\n\n @access_token\n end",
"def save_access_token(token, now)\n File.open('/opt/gluu-server/etc/certs/api_token.json', 'w') do |f|\n JSON.dump(\n {\n token: token,\n exp: now\n },\n f,\n )\n end\n end",
"def scim_oauth_access_token_expires_at\n @attributes[:scim_oauth_access_token_expires_at]\n end",
"def fresh_token\n refresh! if expired?\n access_token\n end",
"def update_token! options = {}\n # Normalize all keys to symbols to allow indifferent access internally\n options = deep_hash_normalize options\n\n self.expires_in = options[:expires] if options.key? :expires\n self.expires_in = options[:expires_in] if options.key? :expires_in\n self.expires_at = options[:expires_at] if options.key? :expires_at\n\n # By default, the token is issued at `Time.now` when `expires_in` is\n # set, but this can be used to supply a more precise time.\n self.issued_at = options[:issued_at] if options.key? :issued_at\n\n # Special case where we want expires_at to be relative to issued_at\n if options.key?(:issued_at) && options.key?(:expires_in)\n set_relative_expires_at options[:issued_at], options[:expires_in]\n end\n\n self.access_token = options[:access_token] if options.key? :access_token\n self.refresh_token = options[:refresh_token] if options.key? :refresh_token\n self.id_token = options[:id_token] if options.key? :id_token\n\n self\n end",
"def build_expires_at\n Time.now.to_i + (30 * 24 * 60 * 60)\nend",
"def get_access_token\n auth = storage['authentication']\n return auth['access_token'] if auth && auth['expires'] > Time.now.to_i\n\n auth = authenticate_client\n storage['authentication'] = auth\n auth['access_token']\n end",
"def regenerate_auth_token\n new_token = oauth.exchange_access_token_info(authentication.auth_token)\n\n # Save the new token and its expiry over the old one\n authentication.update_attributes!(\n auth_token: new_token['access_token'],\n last_expires_at: authentication.expires_at,\n expires_at: Time.now + new_token['expires_in'].to_i,\n )\n\n authentication.auth_token\n end",
"def fresh_token\n refresh! if token_expired?\n access_token\n end",
"def authenticate\n Access.new(\n 'access_token' => access_token,\n 'token_type' => token_type,\n 'expires_in' => 1 << (1.size * 8 - 2) - 1 # Max int value\n )\n end",
"def create\n require 'digest/sha1'\n \n @access_token = AccessToken.new\n @access_token.user_id = current_user.id\n @access_token.last_access = Time.now\n @access_token.token = Digest::SHA1.hexdigest Time.now.to_s\n @access_token.active = true\n \n respond_to do |format|\n if @access_token.save\n format.html { redirect_to(@access_token, :notice => 'Access token was successfully created.') }\n format.xml { render :xml => @access_token, :status => :created, :location => @access_token }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @access_token.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def refresh_time\n self.update_column( :expires, Time.zone.now + TOKEN_LIFE )\n end",
"def refresh(response)\n @access_token = response[:access_token]\n @expires_at = Time.now + response[:expires_in]\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token : self.access_token\n end",
"def refresh_access_token\n return false unless @oauth_access_token.expired?\n\n @oauth_access_token = @oauth_access_token.refresh!\n write_attribute :access_token, @oauth_access_token.token\n write_attribute :access_token_expires_at, @oauth_access_token.expires_at\n true\n end",
"def refresh_access_token!\n self.save! if refresh_access_token\n end",
"def access_token\n # Fetch from cache. We can expect this to be `nil` if unset or expired.\n #\n access_token = read_cache\n\n return access_token if access_token\n\n fetch_new_access_token\n end",
"def access_token\n # Synchronization is needed, otherwise race condition may ensue:\n # Let's assume token has expired, and two threads ask for a new token.\n # Both proceed to fetch the token from remote server, both return,\n # but the first token is no longer valid.\n MUTEX.synchronize do\n token = Nordea::Siirto.redis.get(KEY)\n return token if token\n\n Nordea::Siirto.log('Requesting new access token...')\n payload = response.body\n\n token = payload['access_token']\n expires_in = payload['expires_in'] - EXPIRATION_BUFFER\n Nordea::Siirto.redis.set(KEY, token)\n Nordea::Siirto.redis.expire(KEY, expires_in)\n\n token\n end\n end",
"def access_token\n @access_token ||= ShakeTheCounter::Authentication.renew_access_token(client_id: id, client_secret: secret, refresh_token: refresh_token)[\"access_token\"]\n end",
"def valid_access_token\n self.access_token_expired? ? self.refresh_access_token! : self.access_token\n end",
"def generate_token\n self.status = STATUS[:present]\n self.access_token = SecureRandom.urlsafe_base64(45, true)\n self.expires = Time.zone.now.to_i + TOKEN_LIFE\n self.login_time = Time.zone.now\n self.user_events.build(event_name: 'Login', event_time: Time.zone.now)\n save\n self.access_token\n end",
"def fb_access_token_expired\n self.access_token = nil\n save!\n end",
"def update_token\n client.authorization.update_token!(oauth_data)\n if client.authorization.refresh_token && client.authorization.expired?\n client.authorization.fetch_access_token!\n end\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def access_token_expired?\n Time.zone.now >= self.expires_at\n end",
"def access_token\n User.create_access_token(self)\n end",
"def set_expiring_date\n self.expires_at = self.created_at + 10.minutes\n self.save\n end",
"def getExpiration; @expires; end",
"def set_expire_at_date\n self[:expire_at] = valid_at + 1.year\n end",
"def valid_token\n access_token = find_or_create_doorkeeper_access_token\n create_doorkeeper_access_token if access_token.expired? || access_token.revoked?\n access_token\n end",
"def access_token_expired?\n\t\taccess_token_expires_at && access_token_expires_at < Time.zone.now\n\tend",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def generate_access_token\n self.access_token = Digest::SHA1.hexdigest(\"#{random_salt}#{Time.now.to_i}\")\n end",
"def store_token\n token = auth_response[\"login\"] ? user_defined_token : auth_response[\"token\"]\n if token\n user_config.set :github_user, username\n user_config.set :github_token, token\n cli.say \"Successfully stored GitHub API token.\"\n else\n raise GitHub::BadCredentials, \"Uh oh, your access token couldn't be generated/verified. Please check your credentials and try again.\"\n end\n end",
"def expires\n @expires ||= Time.parse(@data['expires'])\n end",
"def save_authentication_token(token)\n carrier_setting.settings['token'] = token\n carrier_setting.settings['token_expire_date'] = DateTime.now + 7.hours\n carrier_setting.save\n end",
"def access_token=(value)\n reset_agent\n @access_token = value\n end",
"def access_token=(value)\n reset_agent\n @access_token = value\n end",
"def valid_token\n return access_token if access_token && !expiring?\n return access_token if request_access_token\n raise 'No valid access token.'\n end",
"def expiry=(expiry)\n self.expires_on = Date.strptime(expiry, '%m/%y') +1.month\n end",
"def facebook_expires\n Time.at(@json['expires'].to_i)\n end",
"def expiry_time\n ((Time.now.tv_sec + 31556926) * 1000).to_i\n end",
"def generate_access_token\n self.access_token = SecureRandom.hex(64)\n end",
"def refresh_config_from_access_token\n $LOG.i \"saving access token data in config object\"\n \n @config.access_token = @access_token.token\n @config.refresh_token = @access_token.refresh_token\n @config.expires_in = @access_token.expires_in\n @config.expires_at = @access_token.expires_at\n\n\t$LOG.i \"new config is\", @config\n \n @config\n end",
"def set_expiration_date\n self.expiry_date = Date.today + 365.days\n end",
"def access_token=(token)\n @access_token = token\n end",
"def expires_in= new_expires_in\n if !new_expires_in.nil?\n @issued_at = Time.now\n @expires_at = @issued_at + new_expires_in.to_i\n else\n @expires_at = nil\n @issued_at = nil\n end\n end",
"def set_details(access_token, token)\n secret = access_token.respond_to?(:secret) ? access_token.secret : nil\n refresh_token = access_token.respond_to?(:refresh_token) ? access_token.refresh_token : nil\n expires_in, expires_at = token.expiration_date(access_token) if token.class.ancestors.include?(Oauth2Token)\n\n token.token = access_token.token\n token.refresh_token = refresh_token\n token.secret = secret\n token.expires_at = expires_at\n token.expires_in = expires_in\n\n token\n end",
"def generate_authentication_token\n self.auth_token = User.new_token\n\t\t\tself.auth_expires_at = Time.now + 240.hours\n\tend",
"def set_access_token token\n current_user.access_token = token\n config[current_user.environment].access_token = token\n write_config\n end",
"def fresh_hubstaff_access_token\n raise 'Organiaztion not connected to HB. Please edit hubstaff start auth code.' if hubstaff_token_will_end.blank?\n\n # still fresh\n return hubstaff_access_token if hubstaff_token_will_end - 2.hours > DateTime.now\n\n res = HubstaffClient.new.refresh_access_token_request hubstaff_refresh_token\n\n raise StandardError, res.parsed_response['error'] if res.code != 200\n\n self.hubstaff_access_token = res.parsed_response['access_token']\n self.hubstaff_refresh_token = res.parsed_response['refresh_token']\n self.hubstaff_token_get_at = DateTime.now\n self.hubstaff_token_will_end = DateTime.now + (res.parsed_response['expires_in'].to_i / 60.0 / 60.0).round.hours\n\n self.save\n\n hubstaff_access_token\n end",
"def setup_expiration\n self.expires_at = Time.now.utc + ::Simple::OAuth2.config.authorization_code_lifetime if expires_at.nil?\n end",
"def update_token\n\trequire 'date'\n\ttil = Time.at(settings.exp) - Time.now\n\tleft = (til/60).to_i\n\tp left\n\tif left < 5\n\t\tres = RestClient.post( \"https://auth.exacttargetapis.com/v1/requestToken\",\n\t\t\t\t\t\t\t {\n\t\t\t\t\t\t\t\t:clientId => settings.clientId,\n\t\t\t\t\t\t\t\t:clientSecret => settings.clientSecret,\n\t\t\t\t\t\t\t\t:refreshToken => settings.refreshToken,\n\t\t\t\t\t\t\t\t:accessType => \"offline\"\n\t\t\t\t\t\t\t })\n\t\t@res = JSON.parse(res)\n\t\tsettings.oauthToken = @res[\"accessToken\"]\n\t\tsettings.exp = Time.now + @res[\"expiresIn\"]\n\t\tsettings.refreshToken = @res[\"refreshToken\"]\n\tend\t\nend",
"def access_token\n Rails.cache.fetch(\"googl_access_token\", expires_in: 50.minutes) do \n request = { query: { client_id: ENV['GOOGL_CLIENT_ID'],\n client_secret: ENV['GOOGL_CLIENT_SECRET'],\n refresh_token: ENV['GOOGL_REFRESH_TOKEN'],\n grant_type: \"refresh_token\"} }\n\n result = self.class.post(\"/oauth2/v3/token\", request)\n\n result.parsed_response[\"access_token\"]\n end\n end",
"def date_auth_expires=(value)\n @children['date-auth-expires'][:value] = value\n end",
"def access_token\n user_token = @user_token\n goat.transaction do\n if user_token.access_token.nil?\n user_token.access_token = request_token.get_access_token\n if !user_token.access_token.nil?\n goat[user_token.user] = user_token\n end\n end\n end\n @user_token = user_token\n @user_token.access_token\n end",
"def access_token=(value)\n if value.nil? || value.empty?\n fail(ArgumentError, \"Invalid access_token: #{ value }\")\n end\n\n @access_token = value\n end",
"def token_expiration_time\n # Check that user has authenticated\n @local_auth_error = local_auth_error\n return Hash[@error => @local_auth_error] if @local_auth_error\n\n # Return valid date if in test mode\n if @test\n m = MockTimeSync.new\n return m.token_expiration_time\n end\n\n # Decode the token, then get the second dict (payload) from the\n # resulting string. The payload contains the expiration time.\n begin\n decoded_payload = Base64.decode64(@token.split('.')[1])\n rescue\n return Hash[@error => 'improperly encoded token']\n end\n\n # literal_eval the string representation of a dict to convert it to a\n # dict, then get the value at 'exp'. The value at 'exp' is epoch time\n # in ms\n exp_int = JSON.load(decoded_payload)['exp'] # not sure about this\n\n # Convert the epoch time from ms to s\n exp_int /= 1000\n\n # Convert and format the epoch time to ruby datetime.\n exp_datetime = Time.at(exp_int)\n\n exp_datetime\n end",
"def generate_access_token\n begin\n self.access_token = User.new_token\n end while ApiKey.exists?(access_token: access_token)\n end",
"def get_new_access_token\n now = Time.now\n params = {\n body: {\n grant_type: 'urn:ietf:params:oauth:grant-type:uma-ticket',\n ticket: retrieve_ticket,\n client_id: key_info['oxtrust_client_id'],\n client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n client_assertion: generate_json_web_token(now),\n scope: 'oxtrust-api-read oxtrust-api-write'\n }\n }\n req = HTTParty.post('https://localhost/oxauth/restv1/token', params)\n if req.code == 200\n token = req['access_token']\n save_access_token(token, now.to_i + 86_400)\n token\n else\n Puppet.err(\n \"Gluu API HTTP #{req.code}: #{req['error_description']}\",\n )\n end\n end",
"def store_access_token(url, user, token, insecure)\n config = Compliance::Configuration.new\n config.clean\n config['server'] = url\n config['insecure'] = insecure\n config['user'] = user\n config['token'] = token\n config['server_type'] = 'compliance'\n config['version'] = Compliance::API.version(config)\n config.store\n\n [true, 'API access token stored']\n end",
"def set_access_token\n # get the access token from wherever we can\n @access_token ||= (set_oauth_data && @oauth_access_token) || (set_facebook_cookies && @cookie_access_token)\n end",
"def create\n token_response = ResourceAccessTokens::CreateService.new(current_user, resource, create_params).execute\n\n if token_response.success?\n @resource_access_token = token_response.payload[:access_token]\n PersonalAccessToken.redis_store!(key_identity, @resource_access_token.token)\n\n redirect_to resource_access_tokens_path, notice: _(\"Your new access token has been created.\")\n else\n redirect_to resource_access_tokens_path, alert: _(\"Failed to create new access token: %{token_response_message}\") % { token_response_message: token_response.message }\n end\n end",
"def renew_access_token!\n @access_token = nil\n true\n end",
"def access_token_expired?\n\t\t\t\treturn false if self.expires_at.nil?\n\n\t\t\t\t# Expiration date less than now == expired\n\t\t\t\tself.expires_at < Time.now\n\t\t\tend",
"def access_token\n return nil unless (temp_access_token = read_attribute(:access_token))\n # logger.debug2 \"temp_access_token = #{temp_access_token}\"\n encrypt_remove_pre_and_postfix(temp_access_token, 'access_token', 43)\n end",
"def access_token\n return nil unless (temp_access_token = read_attribute(:access_token))\n # logger.debug2 \"temp_access_token = #{temp_access_token}\"\n encrypt_remove_pre_and_postfix(temp_access_token, 'access_token', 43)\n end",
"def regenerate_auth_token!\n generate_auth_token\n set_auth_token_expiry\n\n save\n end",
"def access_token\n @access_token ||= AccessToken.new(caller_service: caller_service, authorizator_service: authorizator_service)\n end",
"def refresh_expiry\n self.expires_at = Time.now + ttl\n end",
"def refresh_access_token\n\t\t\t\trequire \"open-uri\"\n\t\t\t\trequire \"net/http\"\n\t\t\t\trequire \"openssl\"\n\t\t\t\trequire \"base64\"\n\n\t\t\t\turi = URI.parse(\"#{self.add_on.jive_url}/oauth2/token\")\n\t\t\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\t\thttp.use_ssl = true\n\n\t\t\t\trequest = Net::HTTP::Post.new(uri.request_uri)\n\t\t\t\trequest.basic_auth self.add_on.client_id, self.add_on.client_secret\n\t\t\t\trequest.set_form_data({\n\t\t\t\t\t\"refresh_token\" => \"#{self.refresh_token}\",\n\t\t\t\t\t\"grant_type\" => \"refresh_token\",\n\t\t\t\t})\n\n\t\t\t\tresponse = http.request(request)\n\t\t\t\tjson_body = JSON.parse(response.body)\n\n\t\t\t\tif (response.code.to_i != 200)\n\t\t\t\t\traise RuntimeError, json_body[\"error\"].to_s.upcase\n\t\t\t\tend\n\n\t\t\t\tself.access_token = json_body[\"access_token\"]\n\t\t\t\tself.expires_in = json_body[\"expires_in\"]\n\t\t\t\tself.expires_at = json_body[\"expires_in\"].to_i.seconds.from_now\n\t\t\t\tself.save\n\t\t\tend",
"def set_expires_at\n self[:expires_at] = case self.expiry_option \n when :in then Time.now.utc + (self.expiry_days || 3).days\n when :on then self[:expires_at]\n else self[:expires_at]\n end\n end",
"def expire!\n token = nil\n save!\n end",
"def initialize(access_token, expiry, refresh_token, expires_in=nil, refresh_expiry=nil)\n @access_token = access_token\n @refresh_token = refresh_token\n @expiry = expiry.to_i if expiry\n @expires_in = expires_in\n @refresh_expiry = refresh_expiry.to_i\n end",
"def access_token\n end"
] | [
"0.75884575",
"0.7466272",
"0.7466272",
"0.74192274",
"0.7403891",
"0.73633766",
"0.7249434",
"0.7160198",
"0.7129825",
"0.7110655",
"0.70820415",
"0.70564413",
"0.7045412",
"0.69969326",
"0.69928527",
"0.69101036",
"0.6870241",
"0.6809017",
"0.6788108",
"0.6788108",
"0.6770613",
"0.67693317",
"0.6748225",
"0.6747664",
"0.67298424",
"0.6691707",
"0.6673352",
"0.6633125",
"0.6627296",
"0.6612318",
"0.65916556",
"0.65863335",
"0.65840477",
"0.6554421",
"0.65329814",
"0.6510232",
"0.6496551",
"0.64773077",
"0.64666593",
"0.64582133",
"0.64517295",
"0.6448194",
"0.6436899",
"0.6416429",
"0.6399792",
"0.63872427",
"0.63872427",
"0.63872427",
"0.6381926",
"0.6381926",
"0.63812983",
"0.6336364",
"0.6331853",
"0.63123924",
"0.631087",
"0.6285765",
"0.6268128",
"0.6268128",
"0.62610185",
"0.62601703",
"0.62545735",
"0.6247315",
"0.6247315",
"0.62421626",
"0.6233782",
"0.6233019",
"0.622997",
"0.6228521",
"0.62229735",
"0.6222943",
"0.6221584",
"0.62129825",
"0.6210015",
"0.6202664",
"0.6196185",
"0.61920434",
"0.61918",
"0.6189242",
"0.6181876",
"0.6164943",
"0.61572355",
"0.6137457",
"0.61373156",
"0.6129257",
"0.61210287",
"0.6115479",
"0.61147463",
"0.6105997",
"0.6104777",
"0.6104296",
"0.610388",
"0.610388",
"0.61033636",
"0.6103286",
"0.6100601",
"0.60957515",
"0.6075277",
"0.60704947",
"0.6068012",
"0.6065743"
] | 0.812647 | 0 |
JSON method for listing/unlisting course | def list
@course = find_course_by_slug(params[:id])
cohort = Cohort.find_by(title: cohort_params[:title])
unless cohort
render json: {
message: "Sorry, #{cohort_params[:title]} is not a valid cohort."
}, status: 404
return
end
ListCourseManager.new(@course, cohort, request).manage
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show\n render json: @course\n end",
"def show\n render json: course\n end",
"def course\n\t\t@course = Course.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.json\n\t\tend\n\tend",
"def courses\n @courses = Course.where(faculty_id: params[:faculty_id]).order(:name)\n respond_to do |format|\n format.json { render json: @courses }\n end\n end",
"def index\n @courses = Course.all\n render json: @courses, status: :ok\n end",
"def show_course\n\t\t@course = Course.find(params[:course_id])\n\t\trender json: @course\n\tend",
"def get_students\n @course = Course.find(params[:course_id])\n\n render json: @course.students\n end",
"def index\n course = Course.find(params[:course_id])\n sections = course.sections.all\n render json: sections.order(:id)\n end",
"def index\n\t\t@courses = Course.all\n\t\trespond_to do |format|\n\t\t\tformat.html\n\t\t\tformat.json { render json: @courses }\n\t\tend\n\tend",
"def index\n @courses = Course.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses }\n end\n end",
"def index\n @courses = Course.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses }\n end\n end",
"def show\n render json: @course, status: :found\n end",
"def index\n @courses = Course.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses}\n end\n end",
"def index\n \n if can? :update, @course #instructor \n @courses = current_user.subjects #Course.where(:user_id => current_user.id) #courses that person teaches\n else\n @courses = current_user.courses \n end\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses }\n end\n end",
"def list\n #no objects of class (as compared to previous lab)\n #no array!\n @courses = Course.where(\"instructor='John'\")\n end",
"def index\n\t\t@course = Course.find(params[:course_id])\n\t\trespond_to do |format|\n\t\t\tformat.html\n\t\tend\n\tend",
"def index\n # Check for filters\n @courses = Course.getCourseInformation(params[:dept],params[:course])\n @page_title = \"Browse Courses\"\n respond_to do |format|\n format.html\n format.json {render json: @courses }\n end\n end",
"def index\n authorize! :read, Course\n\n if is_student?\n @course_sections = Course.find_student_courses(current_user.id)\n else\n @course_sections = Course.find_professor_courses(current_user.id)\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses }\n end\n end",
"def index\n\t\t@courses = @teacher.courses\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @courses }\n end\n end",
"def show\n render json: {teacher: @course.teacher, course: @course, categories: @course.categories, training_sessions: @course.training_sessions}\n end",
"def student_show\n @course = Course.find(params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n \n end",
"def index\n @courses = Course.where(:user_id=>current_user.id,:deleted=>0)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @courses }\n end\n end",
"def index\n @courses = Course.order(:name).page(params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => Course.all }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @course_roles }\n end\n end",
"def index\n @assessment_courses = AssessmentCourse.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @assessment_courses }\n end\n end",
"def get_course_of_instructor\n instructor_id = params[:instructor_id]\n\n course_ids = if instructor_id.blank?\n []\n else\n Course.where(:user_id => instructor_id).map(&:id).map(&:to_s)\n end\n\n render json: {:course_ids => course_ids}\n end",
"def index\n @courts = Court.by_name\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courts }\n end\n end",
"def courses\n unless user_signed_in? && current_user.instructor\n render :nothing => true, :status => :unauthorized\n end\n \n $selected_course = nil\n\n @courses = current_user.instructor.courses.collect{ |course|\n {\n name: course.name,\n id: course.id\n }\n }\n\n render :template => \"home/index\"\n end",
"def show\n @course = Course.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def courses_json\n raise Exceptions::EducatorNotAuthorized unless current_educator.districtwide_access\n courses = Course.all\n .where(school_id: @school.id)\n .includes(sections: :students)\n\n courses_json = courses.as_json({\n :only => [:id, :course_number, :course_description],\n :include => {\n :sections => {\n :only => [:id, :section_number, :term_local_id, :schedule, :room_number],\n :include => {\n :students => {\n :only => [:id, :grade, :date_of_birth],\n :include => {\n :school => {\n :only => [:id, :name]\n }\n }\n }\n }\n }\n }\n })\n\n render json: {\n courses: courses_json,\n school: @school.as_json(only: [:id, :name])\n }\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @course }\n end\n end",
"def index\n @courses = Course.all.includes(:translations)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @courses }\n end\n end",
"def index\n @enrolleds = Enrolled.all\n @courses = Course.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @enrolleds }\n end\n end",
"def index\n @study_courses = StudyCourse.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @study_courses }\n end\n end",
"def show\n @course = Course.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @course }\n end\n end",
"def all_courses\n [\n {\n id: 1,\n title: 'The Complete Node.js Developer Course',\n author: 'Andrew Mead, Rob Percival',\n description: 'Learn Node.js by building real-world applications with Node, Express, MongoDB, Mocha, and more!',\n topic: 'Node.js',\n url: 'https://codingthesmartway.com/courses/nodejs/'\n },\n {\n id: 2,\n title: 'Node.js, Express & MongoDB Dev to Deployment',\n author: 'Brad Traversy',\n description: 'Learn by example building & deploying real-world Node.js applications from absolute scratch',\n topic: 'Node.js',\n url: 'https://codingthesmartway.com/courses/nodejs-express-mongodb/'\n },\n {\n id: 3,\n title: 'JavaScript: Understanding The Weird Parts',\n author: 'Anthony Alicea',\n description: 'An advanced JavaScript course for everyone! Scope, closures, prototypes, this, build your own framework, and more.',\n topic: 'JavaScript',\n url: 'https://codingthesmartway.com/courses/understand-javascript/'\n }\n ]\n end",
"def index\n @course_statuses = CourseStatus.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @course_statuses }\n end\n end",
"def index\n query = params[:q]\n @courses = query ? Course.search(query) : Course.all.order(:id)\n\n render json: @courses\n end",
"def show\r\n @course = Course.find(params[:id])\r\n\r\n respond_to do |format|\r\n format.html # show.html.erb\r\n format.json { render json: @course }\r\n\r\n end\r\n end",
"def show\n @course = Course.find(params[:id])\n\n # zips programme together coupling names with links\n names = @course.programmes.map(&:name)\n urls = @course.programmes.map(&:url)\n @programme_names_urls = names.zip(urls)\n\n # zips staff together coupling names with links\n names = @course.staffs.map(&:name)\n urls = @course.staffs.map(&:url)\n @staff_names_urls = names.zip(urls) \n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def list_courses(courses_collection)\n courses_collection.each do |course|\n\n end\n end",
"def course; end",
"def index\n\t\t@courses = Course.all\n\tend",
"def list_courses \r\n courses = Subject.find(params[:s]).courses rescue render_return\r\n render_return if courses.empty? or !logged_in_user.see_course?(courses.first)\r\n render_p 'course_display/list_courses',{'courses'=>courses,'caller'=>params[:caller]}\r\n end",
"def show\n @courses = Course.all\n end",
"def show\n respond_with(@course)\n end",
"def course\n unless user_signed_in? && current_user.instructor\n render :nothing => true, :status => :unauthorized\n end\n \n $selected_course = Course.where({id: params[:id]}).first\n\n @course_projects = $selected_course.projects.collect{ |project|\n {\n project_name: project.name,\n team_names: project.teams.reduce(''){|names, team| names + team.name + ', '}[0..-3],\n due: project.due.in_time_zone('Eastern Time (US & Canada)').strftime('%Y-%m-%d %I:%M:%S %p')\n }\n }\n\n render :template => \"home/index\"\n end",
"def show\n @lab_course = LabCourse.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lab_course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n @studysessions = @course.study_sessions\n @myStudySessions = StudySession.where(\"host_id = '#{current_user.id}' AND course_name = '#{@course.name}'\")\n @allstudysessions = StudySession.where(\"(is_private is NULL OR is_private is FALSE) AND course_name = '#{@course.name}'\") - @myStudySessions\n @classmates = @course.getClassmates\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course }\n end\n end",
"def show\n @course = Course.find(params[:id])\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @course }\n end\n end",
"def index\n @given_courses = GivenCourse.all\n end",
"def index\n @courses = Course.all\n\n end",
"def index\n \tif current_user && current_user.username.eql?(\"admin\")\n @courses = Course.all\n elsif current_user\n\t @lista = Profesor.joins(:course).where(:user_id => session[:user_id])\t\n\t list = Array.new\n\t @lista.each do |l|\n\t \tlist << l.course_id\n end\n\t @courses = Course.find(list)\n\tend\n\t\t\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json=> @courses }\n end\n end",
"def assignments\n\t\t@course = Course.find(params[:id])\n\t\t\n\t\trespond_to do |format|\n\t\t\tformat.json\n\t\tend\n\tend",
"def index\n #@courses = @curriculum.courses\n\n @courses = ScopedCourse.where(:curriculum_id => @curriculum.id)\n .joins(:course_descriptions)\n .where([\"course_descriptions.locale = ?\", I18n.locale]).includes(:strict_prereqs)\n# .joins(<<-SQL\n# INNER JOIN course_descriptions\n# ON competence_nodes.abstract_course_id = course_descriptions.abstract_course_id\n# SQL\n# )\n\n respond_to do |format|\n #format.html # index.html.erb\n format.json do\n render :json => @courses.select(<<-SQL\n competence_nodes.id,\n competence_nodes.course_code,\n course_descriptions.name AS translated_name\n SQL\n ).to_json(:methods => :strict_prereq_ids, :root => true)\n end\n end\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def index\n @courses = Course.all\n end",
"def view_all_courses\n\t\t\t# module_grand_access = permission_control(\"course\",\"show\")\n\t\t\tmodule_grand_access = true\n\t\t\tif module_grand_access\n\t\t\t\tcourses = Course.all\n\t\t\t\tif courses.present?\n\t\t\t\t\trender json: courses ,status: :ok\n\t\t\t\telse\n\t\t\t\t\trender json: {error: \"No Courses are created\"}, status: :not_found\n\t\t\t\tend\n\t\t\telse\n \t\t\trender json: { error: \"You dont have permission to perform this action,Please contact Site admin\" }, status: :unauthorized\t\t\t\t\n\t\t\tend\n\t\tend",
"def list_courses\n if current_user.is_admin?\n @user = User.find(params[:id])\n @courses = @user.courses\n respond_to do |format|\n format.xml { render :xml => @courses }\n end\n else\n respond_to do |format|\n format.xml { render :text => \"error\" }\n end\n end\n end",
"def show\n @course = params[:coursename].nil? ? Helpers.filter_teachers_by_course : Helpers.filter_teachers_by_specific_course(params[:coursename])\n render json: { status: 'Success', message: 'Successfully filtered', data: @course }\n end",
"def show\n @course = Course.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @student }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @course_role }\n end\n end",
"def index\n @course = params[:course_id]\n @students = Student.left_join_enrolls @course\n puts @students.as_json\n end",
"def index\n @user = current_user\n @course = Course.find(params[:course_id])\n @course_lessons = @course.course_lessons.order(\"updated_at DESC\")\n if @course_lessons.count == 0\n @course_lesson = CourseLesson.new\n end\n @title = @course.name\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @course_lessons }\n end\n end",
"def index\r\n @courses = Course.all\r\n end",
"def courses\n [self]\n end",
"def courses\n @learn_courses\n end",
"def index\n @first_aid_courses = FirstAidCourse.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @first_aid_courses }\n end\n end",
"def index\n params.require(:course)\n @questions = Course.find(params[:course]).questions.select {|q| q.answered == false}\n\n render json: @questions\n end",
"def get_groups\n @course = Course.find(params[:course_id])\n render json: @course.groups\n end",
"def new\n # make sure that you pass in the list of departments and courses to the views\n @course = Course.new\n @user = current_user\n @subjectHash = Marshal.load (File.binread('script/CourseListSpring')) \n gon.subjectHash = @subjectHash\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @course }\n end\n end"
] | [
"0.7265224",
"0.7218653",
"0.71860796",
"0.7105367",
"0.70431274",
"0.7003885",
"0.69818217",
"0.6977082",
"0.68863916",
"0.68660736",
"0.68660736",
"0.6859482",
"0.6853806",
"0.67557496",
"0.67463326",
"0.67200017",
"0.6648524",
"0.66350806",
"0.66322565",
"0.6601128",
"0.6584898",
"0.65749514",
"0.6568019",
"0.6562317",
"0.65430534",
"0.6531442",
"0.65058976",
"0.65002286",
"0.64760935",
"0.64597464",
"0.6454549",
"0.6454549",
"0.6454549",
"0.6454549",
"0.6454549",
"0.6454549",
"0.6442131",
"0.642603",
"0.64175695",
"0.6413749",
"0.6388423",
"0.6385803",
"0.63685524",
"0.6354472",
"0.63442904",
"0.6343879",
"0.633859",
"0.6337332",
"0.6326238",
"0.6321636",
"0.6319351",
"0.6301124",
"0.62856084",
"0.6278684",
"0.6263726",
"0.62598646",
"0.6254531",
"0.6252774",
"0.62517077",
"0.62484545",
"0.6248295",
"0.6247756",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.624474",
"0.62424654",
"0.6237069",
"0.62267745",
"0.6224884",
"0.6223569",
"0.6220574",
"0.6215061",
"0.62070024",
"0.62026095",
"0.62011015",
"0.61948",
"0.6155518",
"0.614697",
"0.6132041"
] | 0.0 | -1 |
GET /egresos GET /egresos.json | def index
@egresos = Egreso.all.paginate(:per_page => 4, :page => params[:page])
if params[:fecha_fin] == nil || params[:fecha_fin] == ""
params[:fecha_fin]=Date.today
@egresos = Egreso.order("fecha DESC").paginate(:per_page => 4, :page => params[:page]).where("fecha <= ?", params[:fecha_fin].to_date)
else
if params[:fecha_inicio] != nil && params[:fecha_fin] != nil
@egresos = Egreso.order("fecha DESC").paginate(:per_page => 4, :page => params[:page]).where("fecha >= ? and fecha <= ?", params[:fecha_inicio].to_date, params[:fecha_fin].to_date)
end
end
end | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def index\n @ores = Ore.all\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ores }\n end\n end",
"def index\n @ordenes = Orden.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ordenes }\n end\n end",
"def index\n @ginasios = Ginasio.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @ginasios }\n end\n end",
"def index\n @eicons = Eicon.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @eicons }\n end\n end",
"def index\n @equipos = Equipo.all\n render json: @equipos, status: :ok\n end",
"def index\n @foros = Foro.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @foros }\n end\n end",
"def getOrden \n \t@orden = Orden.where(:rest => params[:id_res])\n \trender json: @orden\n end",
"def index\n @electors = Elector.all\n\n render json: @electors\n end",
"def index\n @dia_eventos = DiaEvento.all\n render json: @dia_eventos\n end",
"def index\n @ordens = Orden.all\n render json: @ordens\n end",
"def index\n \n @artigos = Artigo.search(params)\n\n #@artigos = Artigo.search(params)\n #@artigo = Artigo.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @artigos }\n end\n end",
"def events\n url = 'https://api.artic.edu/api/v1/exhibitions?limit=35'\n\n res = RestClient.get(url)\n JSON.parse(res)\nend",
"def index\n @expedientes = Expediente.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @expedientes }\n end\n end",
"def index\n @postos = Posto.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @postos }\n end\n end",
"def index\n @ultimo_grado_de_estudios = UltimoGradoDeEstudio.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ultimo_grado_de_estudios }\n end\n end",
"def index\n @coordenador_estagios = CoordenadorEstagio.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @coordenador_estagios }\n end\n end",
"def index\n @empresas = Empresa.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @empresas }\n end\n end",
"def index\n @ef_pares = EfPare.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ef_pares }\n end\n end",
"def show\n @gethotel = Gethotel.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @gethotel }\n end\n end",
"def index\n @galleries = Gallery.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @galleries }\n end\n end",
"def index\n @galleries = Gallery.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @galleries }\n end\n end",
"def index\n @galleries = Gallery.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @galleries }\n end\n end",
"def show\n @orgao = Orgao.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @orgao }\n end\n end",
"def index\n @galleries = Gallery.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @galleries }\n end\n end",
"def index\n \treclamos = Reclamo.all\n \trender json: reclamos.to_json(include: [:tipo_reclamo, :ubicacion, :user], methods: [:valoracion])\n end",
"def show\n @gasto = Gasto.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @gasto }\n end\n end",
"def show\n @eou = Eou.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @eou }\n end\n end",
"def index\n @ativo_outros = AtivoOutro.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @ativo_outros }\n end\n end",
"def index\n @enderecos = Endereco.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @enderecos }\n end\n end",
"def show\n @estatuto = Estatuto.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @estatuto }\n end\n end",
"def show\n @odontologo = Odontologo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @odontologo }\n end\n end",
"def index\n @fotos = Foto.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @fotos }\n end\n end",
"def index\n @heroes = Hero.all\n\n render json: @heroes\n end",
"def index\n @repas = Repa.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @repas }\n end\n end",
"def index\n @enemigos = Enemigo.all\n end",
"def consulta\n fiesta = Fiesta.all\n render json: fiesta\n end",
"def index\n @ofertas = Oferta.where(:status_id => Status.find_by_descricao('Ativo'))\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @ofertas }\n end\n end",
"def index\n @clientes = Cliente.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @clientes }\n end\n end",
"def index\n @eobs = Eob.assigned\n @title = \"Posted EOBs\"\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @eobs }\n end\n end",
"def show\n @soiree = Soiree.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @soiree }\n end\n end",
"def index\n @colegios = Colegio.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @colegios }\n end\n end",
"def show\n @osoba = Osoba.find(params[:id])\n\n render json: @osoba\n end",
"def index\n @content_explores = ContentExplore.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @content_explores }\n end\n end",
"def index\n @archdioceses = Archdiocese.all\n\n render json: @archdioceses\n end",
"def index\n @web_car_galleries = WebCarGallery.all\n\n render json: @web_car_galleries\n end",
"def index\n @shoes = Shoe.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @shoes }\n end\n end",
"def emergencias_en_curso\n @emergencies = Emergency.where(:estado => 'f')\n render json: @emergencies\n end",
"def index\n @pedidos = Pedido.find(:all,:conditions=> {:status => [0], :user_id => current_user.id})\n if @pedidos.count > 0\n @imagen_pedidos = @pedidos[0].imagen_pedidos\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @imagen_pedidos }\n end\n else\n redirect_to pedidos_path, notice: 'No tiene pedidos pendientes'\n end\n end",
"def show\n @agente = Agente.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @agente } \n end\n end",
"def heros\n get('/hero/')\n end",
"def index\n\t\tvendas = Venda.all\n\t\trender json: vendas, status: :ok\n\tend",
"def index\n @detalles = Detalle.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @detalles }\n end\n end",
"def show\n render json: @elector\n end",
"def lista_estoque()\n @client.get(Route.new([ROTA_DID_ESTOQUE]))\n end",
"def show\n @clientepedido = Clientepedido.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @clientepedido }\n end\n end",
"def index\n info = Aws.get_recipes_from_db\n render :json => info\n end",
"def index\n respond_with Genre.all\n end",
"def index\n @omatsuris = Omatsuri.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @omatsuris }\n format.json { render :json => @omatsuris }\n end\n end",
"def index\n @vehicule_persos = VehiculePerso.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @vehicule_persos }\n end\n end",
"def show\n @exura = Exura.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @exura }\n end\n end",
"def index\n base_url = 'https://www.googleapis.com/books/v1/volumes?q=fiction&maxResults=20'\n and_key = '&key='\n key = ENV['GOOGLE_BOOKS_API_KEY'] \n googleurl = base_url + and_key + key\n\n response = RestClient.get(googleurl)\n @books = JSON.parse(response)\n\n respond_to do |format|\n format.html\n format.json { render json: @books }\n end\n\nend",
"def index\n render json: @fiestas\n end",
"def index\n @mesasredondas = Mesasredonda.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @mesasredondas }\n end\n end",
"def show\n @ecg = Ecg.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @ecg }\n end\n end",
"def index\n @gonzos = Gonzo.all\n end",
"def index\n @estacionamientos = Estacionamiento.all\n\n @json = Estacionamiento.all.to_gmaps4rails\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @estacionamientos }\n end\n end",
"def show\n @peso = Peso.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @peso }\n end\n end",
"def index\n @socios = Socio.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @socios }\n end\n end",
"def index\n @acuerdos = Acuerdo.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @acuerdos }\n end\n end",
"def index\n @endorsements = Endorsement.all\n\n render json: @endorsements\n end",
"def index\n @palestrantes = Palestrante.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @palestrantes }\n end\n end",
"def index\n @episodes = Episode.all\n\n render json: @episodes\n end",
"def index\n @egalleries = Egallery.all(:order => \"id DESC\")\n# @egalleryps = Egalleryp.find(:conditions => {:egalleryp => params[:egalleryps]})\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @egalleries }\n end\n end",
"def index\n @regiones = Region.all\n\n render json: @regiones\n end",
"def index\n @preparatoria_o_universidad_de_origens = PreparatoriaOUniversidadDeOrigen.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @preparatoria_o_universidad_de_origens }\n end\n end",
"def index\n @establecimientos = Establecimiento.all\n respond_to do |format|\n format.json { \n\n if (params[:appkey].eql? appkey) #si el appkey es correcto\n\n ests = @establecimientos.map { |establecimiento| { :nombre_establecimiento => establecimiento.nombre, :id => establecimiento.id, \n :descripcion => establecimiento.descripcion, :longitud => establecimiento.longitud,\n :latitud => establecimiento.latitud, :direccion => establecimiento.direccion, :imagen => establecimiento.foto.url(:small),\n :eventos => establecimiento.eventos.map { |evento| { :nombre => evento.nombre } } } } \n render json: ests\n else\n render json: {:error => \"No autorizado\"}\n end\n\n\n\n }\n format.html { redirect_to :controller=>'login', :action=>'login' } #solo el app movil puede revisar toda la lista de establecimientos.\n end\n end",
"def especies\n\t\tbr = BusquedaRegion.new\n\t\tbr.params = params\n\t\t\n\t\trespond_to do |format|\n\t\t\tformat.html do\n\t\t\t\tbr_guia = BusquedaRegion.new\n\t\t\t\tbr_guia.params = params\n\t\t\t\tbr_guia.valida_descarga_guia\n\t\t\t\t\n\t\t\t\tcache_filtros_ev\n\t\t\t\tbr.especies\n\t\t\t\t@resp = br.resp\n\t\t\t\t@valida_guia = br_guia.resp[:estatus]\n\t\t\tend\n\t\t\tformat.xlsx do\n\t\t\t\tbr.original_url = request.original_url\n\t\t\t\tbr.descarga_taxa_excel\n\t\t\t\trender json: br.resp\n\t\t\tend\n\t\t\tformat.json do\n\t\t\t\tif params[:guia] = \"1\"\n\t\t\t\t\tbr.original_url = request.original_url\n\t\t\t\t\tbr.valida_descarga_guia\n\t\t\t\t\t\n\t\t\t\t\tif br.resp[:estatus]\n\t\t\t\t\t\tbr.descarga_taxa_pdf\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\trender json: br.resp and return\n\t\t\t\telse\n\t\t\t\t\tbr.especies\n\t\t\t\t\trender json: br.resp and return\n\t\t\t\tend\n\t\t\tend\n\t\t\t\n\t\t\tformat.pdf do\n\t\t\t\tbr = BusquedaRegion.new\n\t\t\t\tbr.params = params\n\t\t\t\t\n\t\t\t\tif params[:job].present? && params[:job] == \"1\"\n\t\t\t\t\tbr.original_url = request.original_url\n\t\t\t\t\tbr.valida_descarga_guia\n\t\t\t\t\t\n\t\t\t\t\tif br.resp[:estatus]\n\t\t\t\t\t\tbr.descarga_taxa_pdf\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\trender json: br.resp and return\n\t\t\t\t\n\t\t\t\telse\n\t\t\t\t\tbr.descarga_taxa_pdf\n\t\t\t\t\t@resp = br.resp\n\t\t\t\t\t@url_enciclovida = request.url.gsub('/especies.pdf', '')\n\t\t\t\t\t\n\t\t\t\t\trender pdf: 'Guía de especies',\n\t\t\t\t\t layout: 'guias.pdf.erb',\n\t\t\t\t\t template: 'busquedas_regiones/guias/especies.pdf.erb',\n\t\t\t\t\t encoding: 'UTF-8',\n\t\t\t\t\t wkhtmltopdf: CONFIG.wkhtmltopdf_path,\n\t\t\t\t\t save_to_file: Rails.root.join('public','descargas_guias', params[:fecha], \"#{params[:nombre_guia]}.pdf\"),\n\t\t\t\t\t save_only: true,\n\t\t\t\t\t page_size: 'Letter',\n\t\t\t\t\t page_height: 279,\n\t\t\t\t\t page_width: 215,\n\t\t\t\t\t orientation: 'Portrait',\n\t\t\t\t\t disposition: 'attachment',\n\t\t\t\t\t disable_internal_links: false,\n\t\t\t\t\t disable_external_links: false,\n\t\t\t\t\t header: {\n\t\t\t\t\t\t\t html: {\n\t\t\t\t\t\t\t\t\t template: 'busquedas_regiones/guias/header.html.erb'\n\t\t\t\t\t\t\t }\n\t\t\t\t\t },\n\t\t\t\t\t footer: {\n\t\t\t\t\t\t\t html: {\n\t\t\t\t\t\t\t\t\t template: 'busquedas_regiones/guias/footer.html.erb'\n\t\t\t\t\t\t\t },\n\t\t\t\t\t }\n\t\t\t\t\t\n\t\t\t\t\trender json: { estatus: true } and return\n\t\t\t\tend\n\t\t\tend\n\t\t\n\t\tend\n\tend",
"def index\n @chores = Chore.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @chores }\n end\n end",
"def index\n @chores = Chore.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @chores }\n end\n end",
"def index\n @genotypes = Genotype.paginate(:page => params[:page], :per_page => 10)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @genotypes }\n end\n end",
"def show\n @escola = Escola.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @escola }\n end\n end",
"def index\n @distros = getmydata(\"Distro\")\n pagination\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @distros }\n end\n end",
"def show\n @gastos = Gasto.all\n @company = Company.find(1)\n @locations = @company.get_locations()\n @divisions = @company.get_divisions()\n @documents = @company.get_documents()\n @cajas = Caja.all \n @employees = @company.get_employees \n @egresos = Egreso.order(:code)\n end",
"def show\n @gastos = Gasto.all\n @company = Company.find(1)\n @locations = @company.get_locations()\n @divisions = @company.get_divisions()\n @documents = @company.get_documents()\n @cajas = Caja.all \n @employees = @company.get_employees \n @egresos = Egreso.order(:code)\n end",
"def index\n render :json => Producto.all\n end",
"def show\n @estoque = Estoque.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @estoque }\n end\n end",
"def show\n @escala = Escala.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @escala }\n end\n end",
"def index\n @processos = Processo.all\n\n render json: @processos\n end",
"def index\n @comentario_egresados = ComentarioEgresado.all\n end",
"def index\n @acoes = Acao.all\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @acoes }\n end\n end",
"def index\n @events = Event.all\n render json: @events\n end",
"def index\n @listes = Liste.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @listes }\n end\n end",
"def index\n @events = Event.all\n\n render json: @events\n end",
"def show\n @veiculo = Veiculo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @veiculo }\n end\n end",
"def index\n @relaciones_articulos_medida = RelacionArticuloMedida.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @relaciones_articulos_medida }\n end\n end",
"def index\n @cegresos = Cegreso.all\n end",
"def index\n @extras = Extra.all\n\n render json: @extras\n end",
"def index\n @evas = Eva.all\n end",
"def index\n @lugars = Lugar.all\n\n render json: @lugars\n end",
"def index\n @cartridges = Cartridge.all\n\n respond_to do |format|\n format.html\n format.json { render json: @cartridges }\n end\n end",
"def index\n @verbindungs = Verbindung.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @verbindungs }\n end\n end"
] | [
"0.6681978",
"0.649372",
"0.6453615",
"0.64527774",
"0.63053507",
"0.62851405",
"0.62781173",
"0.62663895",
"0.6256521",
"0.6237189",
"0.62178934",
"0.6208452",
"0.6179376",
"0.61765134",
"0.61563206",
"0.61477417",
"0.61129606",
"0.6085213",
"0.6040708",
"0.60372585",
"0.60372585",
"0.60372585",
"0.60210747",
"0.60176235",
"0.60151124",
"0.6012612",
"0.60078603",
"0.6006305",
"0.60015666",
"0.5992058",
"0.59917855",
"0.5987231",
"0.59863913",
"0.5967924",
"0.59576076",
"0.59523",
"0.59453744",
"0.5938649",
"0.5932036",
"0.5926675",
"0.59193003",
"0.5913035",
"0.59113497",
"0.5907789",
"0.5901475",
"0.58906037",
"0.58805335",
"0.5878872",
"0.58745253",
"0.58741426",
"0.58680487",
"0.58630824",
"0.5862817",
"0.58513063",
"0.5848985",
"0.5847377",
"0.5842188",
"0.5838866",
"0.583429",
"0.5827106",
"0.58269715",
"0.58265346",
"0.582528",
"0.58180434",
"0.58152163",
"0.58142895",
"0.58114004",
"0.58103806",
"0.58103144",
"0.58057237",
"0.580517",
"0.58019316",
"0.58017236",
"0.5801619",
"0.57928133",
"0.57922286",
"0.57919014",
"0.5790827",
"0.5790827",
"0.5790486",
"0.5787254",
"0.5781207",
"0.57782143",
"0.57782143",
"0.5773261",
"0.57699114",
"0.57697433",
"0.5760975",
"0.576094",
"0.57576436",
"0.5748126",
"0.57470614",
"0.57468545",
"0.5745811",
"0.57453865",
"0.57432884",
"0.5742343",
"0.5740821",
"0.5740427",
"0.57402474",
"0.57396865"
] | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.