query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives listlengths 19 19 | metadata dict |
|---|---|---|---|
GET /property_between_floor_slaps GET /property_between_floor_slaps.json | def index
@property_between_floor_slaps = PropertyBetweenFloorSlap.all
end | [
"def within_bounds\n min_latitude = Float(params[:sw_latitude])\n max_latitude = Float(params[:ne_latitude])\n min_longitude = Float(params[:sw_longitude])\n max_longitude = Float(params[:ne_longitude])\n limit = 1000 || params[:limit]\n offset = 0 || params[:offset]\n approved = true || params... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /property_between_floor_slaps POST /property_between_floor_slaps.json | def create
@property_between_floor_slap = PropertyBetweenFloorSlap.new(property_between_floor_slap_params)
respond_to do |format|
if @property_between_floor_slap.save
format.html { redirect_to @property_between_floor_slap, notice: 'Property between floor slap was successfully created.' }
format.json { render :show, status: :created, location: @property_between_floor_slap }
else
format.html { render :new }
format.json { render json: @property_between_floor_slap.errors, status: :unprocessable_entity }
end
end
end | [
"def index\n @property_between_floor_slaps = PropertyBetweenFloorSlap.all\n end",
"def create\n @shooting_range = ShootingRange.new(params[:shooting_range])\n\n respond_to do |format|\n if @shooting_range.save\n format.html { redirect_to(@shooting_range, :notice => 'Shooting range was succes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /property_between_floor_slaps/1 PATCH/PUT /property_between_floor_slaps/1.json | def update
respond_to do |format|
if @property_between_floor_slap.update(property_between_floor_slap_params)
format.html { redirect_to @property_between_floor_slap , notice: 'Property between floor slap was successfully updated.' }
format.json { render :show, status: :ok, location: @property_between_floor_slap }
else
format.html { render :edit }
format.json { render json: @property_between_floor_slap.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n respond_to do |format|\n if @property_land_shape.update(property_land_shape_params)\n format.html { redirect_to @property_land_shape, notice: 'Property land shape was successfully updated.' }\n format.json { render :show, status: :ok, location: @property_land_shape }\n else\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /property_between_floor_slaps/1 DELETE /property_between_floor_slaps/1.json | def destroy
@property_between_floor_slap.destroy
respond_to do |format|
format.html { redirect_to property_between_floor_slaps_url, notice: 'Property between floor slap was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @property_road.destroy\n respond_to do |format|\n format.html { redirect_to property_roads_url, notice: 'Property road was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_floor_plan(args = {}) \n delete(\"/files.json/floorplan/images\", ar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unregisters the webhook with Jive | def unregister_webhook
require "open-uri"
require "net/http"
require "openssl"
return if self.add_on.nil? # Can't do it without a token!
return if self.oauth_token.nil? # Can't do it without a token!
uri = URI.parse("#{self.add_on.jive_url}/api/core/v3/webhooks/#{self.webhook_id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer #{self.oauth_token.access_token}"
response = http.request(request)
# Need 2XX status code
if !response.code.to_i.between?(200, 299)
errors[:base] << "#{request.inspect} => #{response.body}"
return false
end
true
end | [
"def remove_webhook\n request(URL::WEBHOOK, url: '')\n end",
"def delete_webhook\n send_request('deleteWebhook', {})\n end",
"def unsubscribe_request_hook(name)\n EasyPost::Hooks.unsubscribe(:request, name)\n end",
"def delete_webhook(target_url)\n Uploadcare::Webhook.delete(t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Registers the webhook with Jive | def register_webhook
require "open-uri"
require "net/http"
require "openssl"
uri = URI.parse("#{self.add_on.jive_url}/api/core/v3/webhooks")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
#http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer #{self.oauth_token.access_token}"
body = {
"callback" => self.callback,
"object" => self.object,
}
body["events"] = self.events if !self.events.to_s.empty?
request.body = body.to_json
response = http.request(request)
# Need 2XX status code
if !response.code.to_i.between?(200, 299)
errors[:base] << "#{request.inspect} => #{response.body}"
return false
end
json_body = JSON.parse(response.body)
self.webhook_id = json_body["id"]
true
end | [
"def create_webhook(webhook_id, request)\n start.uri('/api/webhook')\n .url_segment(webhook_id)\n .body_handler(FusionAuth::JSONBodyHandler.new(request))\n .post()\n .go()\n end",
"def create_webhook(webhook_id, request)\n start.uri('/api/webhook')\n .... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Refresh one feed source and return the updated feed items | def refresh
FeedSource.find(params[:feed_source_id]).refresh
feed_sources = params[:feed_sources]
@feed_source_titles = {}
FeedSource.find(feed_sources).each { |source| @feed_source_titles[source.id] = source.title}
@feed_items = FeedItem.where("feed_source_id IN (?)", feed_sources).order(pub_date: :desc).limit(20).offset(0)
@feed_items = @feed_items.sort_by{ |item| item.pub_date.to_i }.reverse
render :index
end | [
"def refresh_feed(feed)\n FeedRefreshManager.refresh feed, self\n end",
"def update!\n data = fx_feed.get\n data = remove_cached_records(data)\n data.each(&:save)\n end",
"def refresh!\n fetch_data\n end",
"def refresh\n raise \"Source classes must implement their own ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Store page title options that are used on I18n interpolation. | def page_title_options
@page_title_options ||= {}
end | [
"def page_title(options = {})\n return \"\" if @page.title.blank?\n\n options = {\n prefix: \"\",\n suffix: \"\",\n separator: \"\"\n }.update(options)\n title_parts = [options[:prefix]]\n title_parts << if response.status == 200\n @page.title\n else\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Override in the subclass to provide a place to do initialization of game logic, load files, set up state, etc | def game_setup
end | [
"def initialize\n\t\tinitialize_game\n\tend",
"def initialize_game\n setup_boards\n end",
"def process_init\n end",
"def post_init\n end",
"def initialize(parent_wnd)\r\n super(parent_wnd)\r\n \r\n @core_game = nil\r\n @splash_name = File.join(@resource_path, \"icons/mariazza_tit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called on an instance of the subclass, this will run the game_setup method and then begin the show loop on the delegate | def game_start
game_setup
@console_delegate.show
end | [
"def game_setup\n end",
"def setup_game\n\t\t@game_board = Board.new\n\t\t@game_engine = GameEngine.new(@game_board)\n\t\tupdate_ui\n\tend",
"def setup_new_game\n Game.new.play\n end",
"def run\r\n @log.debug \"Run the tester...\"\r\n @dlg_box = CupSingleGameWin.new(@options)\r\n @dlg_bo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the chat property value. The chat between the user and Teams app. | def chat
return @chat
end | [
"def chat_info\n return @chat_info\n end",
"def chat_info\n return @chat_info\n end",
"def chat\n @_chat || payload && payload['chat']\n end",
"def chat=(value)\n @chat = value\n end",
"def chat\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the chat property value. The chat between the user and Teams app. | def chat=(value)
@chat = value
end | [
"def set_chat(chat)\n @msg.chat = chat if @msg\n end",
"def chat_info=(value)\n @chat_info = value\n end",
"def chat_info=(value)\n @chat_info = value\n end",
"def chat_id=(value)\n @chat_id = value\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Instantiates a new userScopeTeamsAppInstallation and sets the default values. | def initialize()
super
@odata_type = "#microsoft.graph.userScopeTeamsAppInstallation"
end | [
"def initialize()\n super\n @odata_type = \"#microsoft.graph.teamworkApplicationIdentity\"\n end",
"def installed_apps()\n return MicrosoftGraph::Me::JoinedTeams::Item::InstalledApps::InstalledAppsRequestBuilder.new(@path_parameters, @request_adapter... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GPS version Returns an array of projects that are similar if project exists | def project_exists
if self.check_project_exists == true
return (Project.select{ |proj| proj.project_type == self.project_type } && Project.select{ |proj| proj.street1.to_f.between?((self.street1.to_f - 0.02), (self.street1.to_f + 0.02))} && Project.select{ |proj| proj.street2.to_f.between?((self.street2.to_f - 0.02), (self.street2.to_f + 0.02 ))})
else
return []
end
end | [
"def nearby_projects(projects,latitude,longitude)\n @projects_seventy_five = @matched_projects\n # to remove duplicates from array\n @projects_fifty = @projects_seventy_five - @projects_fifty\n @seventy_five = false\n @hundred = false\n matched_projects = projects.near([latitude, longitude], 50, u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GPS version check for projects that have similar streets reversing street order as necessary. | def check_project_exists
# if latitude is within +/- 2 ten-thounsandths of another project's latitude it is the same
(Project.select{ |proj| proj.project_type == self.project_type }.count > 0 && Project.select{ |proj| proj.street1.to_f.between?((self.street1.to_f - 0.002), (self.street1.to_f + 0.002))}.count > 0 && Project.select{ |proj| proj.street2.to_f.between?((self.street2.to_f - 0.02), (self.street2.to_f + 0.02))}.count > 0)
end | [
"def street_similar(form_street_address,va_street_address)\n return false if va_street_address.nil?\n return va_street_address.jarowinkler_similar(form_street_address) > 0.8 ? true : false\n end",
"def nearby_projects(projects,latitude,longitude)\n @projects_seventy_five = @matched_projects\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Details: Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or null/nil value then it should return an empty array. For example: solution([1, 2, 10, 50, 5]) should return [1,2,5,10,50] solution(nil) should return [] | def solution(nums)
nums.to_a.sort
end | [
"def solution(nums)\n nums.nil? ? [] : nums.sort\nend",
"def sort_array(nums)\n nums.nil? ? [] : nums.sort\nend",
"def introspective_sort(array)\n return array if array.empty?\n\n depth_limit = (2 * Math.log10(array.size) / Math.log10(2)).floor\n quick_sort(array, depth_limit)\nend",
"def sorting(numbers... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /regionextras GET /regionextras.json | def index
@regionextras = Regionextra.all
end | [
"def region\n @regions = @company.companyregions\n respond_with @regions\n end",
"def regions\n client.get_stats('/stats/regions')\n end",
"def regions\n @carrierRegions = []\n if session[:carrier]\n soap_client = MyFreightWorldCarrier.new\n @carrierRegions = soap_client.getRegions(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /regionextras POST /regionextras.json | def create
@regionextra = Regionextra.new(regionextra_params)
respond_to do |format|
if @regionextra.save
format.html { redirect_to @regionextra, notice: 'Regionextra was successfully created.' }
format.json { render :show, status: :created, location: @regionextra }
else
format.html { render :new }
format.json { render json: @regionextra.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @region = Region.new(region_params)\n\n if @region.save\n render json: @region, status: :created, location: @region\n else\n render json: @region.errors, status: :unprocessable_entity\n end\n end",
"def createregion\n region_name = params[\"regionName\"]\n region_active ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /regionextras/1 PATCH/PUT /regionextras/1.json | def update
respond_to do |format|
if @regionextra.update(regionextra_params)
format.html { redirect_to @regionextra, notice: 'Regionextra was successfully updated.' }
format.json { render :show, status: :ok, location: @regionextra }
else
format.html { render :edit }
format.json { render json: @regionextra.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @region = Region.find(params[:id])\n\n if @region.update(region_params)\n head :no_content\n else\n render json: @region.errors, status: :unprocessable_entity\n end\n end",
"def update\n do_load_resource\n get_project_if_exists\n do_authorize_instance\n\n @original... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /regionextras/1 DELETE /regionextras/1.json | def destroy
@regionextra.destroy
respond_to do |format|
format.html { redirect_to regionextras_url, notice: 'Regionextra was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @region.destroy\n\n respond_to do |format|\n format.html { redirect_to regions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @region.destroy\n\n head :no_content\n end",
"def destroy\n @region.destroy\n respond_to do |format|\n format.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=begin need function that takes and argument that argument will be an array reference value to check against if the next number is bigger than reference value it becomes the reference value at the end of iterating over each item the reference value the largest number =end | def max_value(our_array)
reference = -100000
our_array.each do |number|
if number > reference
reference = number
end
end
reference
end | [
"def max_number(our_array)\n\treference = -1000000\n\tour_array.each do |number|\n\t\tif number > reference\n\t\t\treference = number\n\t\tend\n\tend\n\treference\nend",
"def largest(array)\n index = 0 #1\n greatest_num = array[index] #5 \n while index < arr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Overwrites slug_exists? from Slug. We allow duplicate slugs on different published_at dates. | def slug_exists?
Article.on(published_at).where(slug: slug).exists?
end | [
"def slug_unique?(test_slug, existing = existing_slugs)\n !existing.include?(test_slug)\n end",
"def slug_unique?(slug)\n self.class.find_by(slug: slug).nil?\n end",
"def slug_is_unique\n true\n end",
"def slug_unchanged?(slug)\n self.slug == slug\n end",
"def slugged?\n !slug.bla... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
START Feed Action Tests | def test_get_feed
get :feed
assert_response :success
end | [
"def test_mp3_feed_works\n get \"/podcast_feed/all/mp3/rss.xml\"\n assert last_response.ok?\n end",
"def test\n @entries = @feed.test\n rescue Exception => e\n flash[:error] = e.message\n redirect_to(admin_feeds_url)\n end",
"def test_feed_user\n user = create(:user)\n changesets = creat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Class method version of Gorilla::Unitnormalize, to handle, e.g., Enumerable, Numeric, and Range objects. | def normalize input, &block
case input
when Range
normalize(input.min, &block)..normalize(input.max, &block)
when Enumerable
input.map { |unit| normalize unit, &block }
when Numeric
normalize Unit.new(input), &block
else # Unit, etc.
input.normalize(&block)
end
end | [
"def convert_units(obj, un)\n begin\n obj.convert_units(un) # for GPhys etc\n rescue\n obj.convert2(un) # for UNumeric etc\n end\n end",
"def normalize_units(u)\n if u.blank?\n u = nil\n else\n u = u.to_s\n u = UNIT_SYN[... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns whether a unit was defined as metric. ==== Example class Coolness true end Coolness.new(1, :megaFonzie).metric? => true | def metric?
unit and self.class.rules[unit][:metric] || false
end | [
"def metric?\n @metric\n end",
"def metric_ton? = unit == 'metric-ton'",
"def is_metric?(unit)\n return (unit == \"mm\" || unit == \"cm\" || unit == \"m\" || unit == \"km\")\n end",
"def metric?\n false\n end",
"def cup_metric? = unit == 'cup-metric'",
"def square_meter? = unit == 'squ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get exception status detail | def status_details(exception)
StatusDetails.new(message: exception&.message, trace: exception&.backtrace&.join("\n"))
end | [
"def status_details\n return nil unless cause.respond_to? :status_details\n cause.status_details\n end",
"def status\n return 404 if NOT_FOUND_ERRORS.include? @exception.class.to_s\n @exception.respond_to?(:http_status) ? @exception.http_status : 500\n end",
"def get_http_status ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieve all CPEs and their associated variants. The 'live' field in the output indicates whether any advisory has been shipped for that CPE and variant. This API does not require authentication. :apiurl: /api/v1/security/cpes :apimethod: GET :apiresponseexample: file:publican_docs/Developer_Guide/api_examples/cpes.json | def cpes
@variants = Variant.all.group_by{|variant| variant.cpe || ''}.sort_by{|cpe,v| cpe}
end | [
"def index\n if params[:cep]\n @api_ceps = Api::Cep.find_by(cep: params[:cep])\n if @api_ceps\n render json: {ceps: @api_ceps}, status: 202\n else\n render json: {error: 'CEP not found'}, status: 404\n end\n else\n @api_ceps = Api::Cep.all\n render json: {ceps: @api... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a SUBSCRIBE frame. Sets `ack` header to 'auto' unless it is already set to 'client' or 'clientindividual'. | def subscribe_frame d, h
h[:ack] = 'auto' unless ['client', 'client-individual'].include?(h[:ack])
create_frame 'SUBSCRIBE', [{:id => OnStomp.next_serial}, h, {:destination => d}]
end | [
"def subscribe_frame d, h\n h[:ack] = 'auto' unless h[:ack] == 'client'\n create_frame 'SUBSCRIBE', [{:id => OnStomp.next_serial}, h, {:destination => d}]\n end",
"def test_client_ack_with_symbol_10\n if @conn.protocol != Stomp::SPL_10\n assert true\n return\n end\n queue = make_destinat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an ACK frame | def ack_frame *args
create_ack_or_nack 'ACK', args
end | [
"def sendAck\n $LOG.debug \"Sending ACK\"\n send_msg ack Messages::EndType::ACK\n end",
"def ack_frame *args\n headers = args.last.is_a?(Hash) ? args.pop : {}\n m_id = args.shift\n m_id = m_id[:'message-id'] if m_id.is_a?(OnStomp::Components::Frame)\n create_frame('ACK', [{:'message-id' => m_id... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an NACK frame | def nack_frame *args
create_ack_or_nack 'NACK', args
end | [
"def ack_frame *args\n create_ack_or_nack 'ACK', args\n end",
"def makeframe(packetdata)\n\t\tif packetdata.size > 255\n\t\t\tprint_error(\"#{rhost}:#{rport} - MODBUS - Packet too large: #{packetdata.inspect}\")\n\t\t\treturn\n\t\tend\n\t\tpayload = \"\"\n\t\tpayload += [@modbuscounter].pack(\"n\")\n\t\tpaylo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a heartbeat frame (serialized as a single "\n" character) | def heartbeat_frame
OnStomp::Components::Frame.new
end | [
"def sendHeartbeat()\n send!(0, :HB, -1, -1, -1, -1)\n end",
"def send_heartbeat(sequence)\n send_packet(Opcodes::HEARTBEAT, sequence)\n end",
"def make_event_frame( payload )\n\t\tframe = Mongrel2::WebSocket::Frame.new( '', 0, '', {}, payload )\n\t\tframe.opcode = :text\n\n\t\treturn frame.to_s\n\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
tyear, tmonth, tweek assigned where setting spent_on attributes these attributes make time aggregations easier | def spent_on=(date)
super
self.tyear = spent_on ? spent_on.year : nil
self.tmonth = spent_on ? spent_on.month : nil
self.tweek = spent_on ? spent_on.cweek : nil
end | [
"def spent_on=(date)\n super\n self.tyear = spent_on ? spent_on.year : nil\n self.tmonth = spent_on ? spent_on.month : nil\n self.tweek = spent_on ? Date.civil(spent_on.year, spent_on.month, spent_on.day).cweek : nil\n self.spent_from = date\n self.spent_to = self.spent_from.advance(:hours=>hours)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /stay_times GET /stay_times.json | def index
@stay_times = StayTime.all
end | [
"def index\n get_todays_data\n\n respond_to do |format|\n format.html { }\n format.json { json_response(@set_times) }\n end\n end",
"def index\n @time_entries = TimeEntry.all\n render :json => @time_entries, status: :ok\n end",
"def index\n \n @task_time... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /stay_times POST /stay_times.json | def create
@stay_time = StayTime.new(stay_time_params)
respond_to do |format|
if @stay_time.save
format.html { redirect_to @stay_time, notice: 'Stay time was successfully created.' }
format.json { render :show, status: :created, location: @stay_time }
else
format.html { render :new }
format.json { render json: @stay_time.errors, status: :unprocessable_entity }
end
end
end | [
"def index\n @stay_times = StayTime.all\n end",
"def create\n @timing = Timing.new(params[:timing].slice(:start, :stop, :days, :parent_class, :parent_id, :active))\n if @timing.save\n render json: @timing\n else\n render json: { error: 'error: could not save timing' }\n end\n end",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /stay_times/1 PATCH/PUT /stay_times/1.json | def update
respond_to do |format|
if @stay_time.update(stay_time_params)
format.html { redirect_to @stay_time, notice: 'Stay time was successfully updated.' }
format.json { render :show, status: :ok, location: @stay_time }
else
format.html { render :edit }
format.json { render json: @stay_time.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @task_time = @task.task_times.find(params[:id])\n\n respond_to do |format|\n if @task_time.update_attributes(params[:task_time])\n format.html { redirect_to task_time_path(@task,@task_time), notice: 'Task time was successfully updated.' }\n format.json { head :no_content }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /stay_times/1 DELETE /stay_times/1.json | def destroy
@stay_time.destroy
respond_to do |format|
format.html { redirect_to stay_times_url, notice: 'Stay time was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @time_gap = TimeGap.find(params[:id])\n @time_gap.destroy\n\n respond_to do |format|\n format.html { redirect_to time_gaps_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @food_time = FoodTime.find(params[:id])\n @food_time.destroy\n\n respond_to do |fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a list of open hours grouped by same days | def grouped_open_hours
open_hours = []
start_day = nil
end_day = nil
current_period = nil
standard_hours.sort.each_with_index do |o, i|
if not o.open?
period = "Stengt"
else
period = I18n.l(o.open_time, format: :time) + " - " + I18n.l(o.close_time, format: :time)
end
# Track day
if start_day == nil
start_day = o.day
current_period = period
end
# Previous group ended, add it
if period != current_period
day = I18n.t("days.#{start_day}")
if end_day != nil
day += " - " + I18n.t("days.#{end_day}")
end
# Hverdager custom string
if start_day == "monday" and end_day == "friday"
day = "Hverdager"
end
open_hours.append([day, current_period])
current_period = period
start_day = o.day
end_day = nil
end
# Update period end
if start_day != o.day
end_day = o.day
end
# Last day closes period
if i >= standard_hours.count - 1
day = I18n.t("days.#{start_day}")
if end_day != nil
day += " - " + I18n.t("days.#{o.day}")
end
open_hours.append([day, current_period])
end
end
open_hours
end | [
"def group_days_of_hours\n last_opens_match, last_closes_match, last_closed_match = nil, nil, nil\n matched_days = []\n groups = []\n\n DAYS.each do |day|\n hours = hours_for_day(day)\n if !matched_days.empty? && hours_match(last_closed_match, hours[0], last_opens_match, hours[1], last_closes_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /graphium/cities GET /graphium/cities.json | def index
@graphium_cities = Graphium::City.all
end | [
"def cities\n self.class.get(\"/v1/cities\")\n end",
"def cities(country_code)\n request(:get, \"/api/cities?country=#{country_code}\")\n end",
"def index\n \n render json: @cities\n end",
"def city\n fetch('dune.cities')\n end",
"def find_cities\n cities = CS.citie... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /graphium/cities POST /graphium/cities.json | def create
@graphium_city = Graphium::City.new(graphium_city_params)
respond_to do |format|
if @graphium_city.save
format.html { redirect_to @graphium_city, notice: 'City was successfully created.' }
format.json { render :show, status: :created, location: @graphium_city }
else
format.html { render :new }
format.json { render json: @graphium_city.errors, status: :unprocessable_entity }
end
end
end | [
"def parse_and_add_cities\n\n cities_list = @json_dict['metros'] \n cities_list.each do |city_dict|\n @json_graph_api.add_vertex(city_dict['code'],city_dict)\n @city_to_code[city_dict['name']] = city_dict['code']\n end\n\n end",
"def index\n @graphium_cities = Graphium::City.all\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /graphium/cities/1 PATCH/PUT /graphium/cities/1.json | def update
respond_to do |format|
if @graphium_city.update(graphium_city_params)
format.html { redirect_to @graphium_city, notice: 'City was successfully updated.' }
format.json { render :show, status: :ok, location: @graphium_city }
else
format.html { render :edit }
format.json { render json: @graphium_city.errors, status: :unprocessable_entity }
end
end
end | [
"def update_tenant_circle(args = {}) \n put(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def update\n respond_to do |format|\n if @city.update(city_params)\n format.json { head :no_content }\n else\n format.json { render json: @city.errors, status: :unprocessable_entity }\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /graphium/cities/1 DELETE /graphium/cities/1.json | def destroy
@graphium_city.destroy
respond_to do |format|
format.html { redirect_to graphium_cities_url, notice: 'City was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n @api_city.destroy\n\n head :no_content\n end",
"def destroy\n @city.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def delete_graph(p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Link to kata: Description: Fix the function I created this function to add five to any number that was passed in to it and return the new value. It doesn't throw any errors but it returns the wrong number. Can you help me fix the function? Answer: | def addFive(num)
num + 5
end | [
"def add_five(number)\n number + 5\nend",
"def increaseSum(sum, num)\n return sum += num;\nend",
"def times_three_and_plus_five(number)\n\t\n total = (number * 3) + 5\n puts total\n \nend",
"def round_to_next_5(n)\n n % 5 == 0 ? n : (n/5 + 1) * 5\nend",
"def times_three_and_plus_five(number)\n nu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /productors GET /productors.json | def index
@productors = Productor.all
end | [
"def product(name)\n get(\"/apiproducts/#{name}\")\n end",
"def index\n @products = Product.all\n render json: @products\n end",
"def index\n @productos_jsons = ProductosJson.all\n end",
"def get_product_list\n request_path = \"/products\"\n return RestClient.get(@api+request_path... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /productors POST /productors.json | def create
@productor = Productor.new(productor_params)
respond_to do |format|
if @productor.save
format.html { redirect_to @productor, notice: 'Productor was successfully created.' }
format.json { render :show, status: :created, location: @productor }
else
format.html { render :new }
format.json { render json: @productor.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @product = Product.new(product_args)\n\n if @product.save\n render json: Product.all, status: :created\n else\n render json: @product.errors, status: :unprocessable_entity\n end\n end",
"def create\n if params[:products]\n params[:products].each do |product|\n @... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns Allows us to get individual returns from the API | def returns(periodKey)
self.class.get(url("returns", periodKey), headers: @headers )
end | [
"def index\n @returns = Return.all\n end",
"def index\n @returneds = Returned.all\n end",
"def find_returns\n\t\tbus = Bus.find(params[:bus_id])\n\t\t@return_buses = bus.find_returns(params[:dep_id] == '0' ? true : false).select{|rb| (!rb.maximum_seats || rb.available_tickets(params[:dep_id] == '0' ? 't... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
this determines the reading order from the stub_object_type (default ltr unless the object type contains one of the possible "rtl" designations) | def book_reading_order
return 'right-to-left' if stub_object_type.include?('rtl') || stub_object_type.include?('r-l')
'left-to-right'
end | [
"def reading_order\n return unless content_md_creation_style == :simple_book\n\n if content_structure == 'simple_book_rtl'\n 'right-to-left'\n else\n 'left-to-right'\n end\n end",
"def reading_direction\n\t return MangaUtils::ReadingDirection::RIGHT_TO_LEFT\n\tend",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /investments GET /investments.json | def index
@investments = Investment.all
respond_to do |format|
format.html
format.json
end
end | [
"def index\n @investments = Investment.all\n\n render json: {investments: @investments}, root: false\n end",
"def index\n @investments = Investment.all\n end",
"def show\n @investment = Investment.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Record has a fixed barcode length | def shift_barcode_length
return unless record.barcode_length
shift_fixed_length(record.barcode_length)
end | [
"def determine_record_length(record_length)\n\n sans_size = TAR_CHUNK_SIZE-1\n\n if(record_length % TAR_CHUNK_SIZE != 0)\n record_length = (record_length + sans_size) & ~sans_size;\n end\n return record_length\n end",
"def barcode_validation(new_barcode)\n if new_barcode.to_s.length == 13\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines the public IP address of the running AWS instance | def determine_public_ip
# 169.254.169.254 is the address of the AWS instance metadata service
# See https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-retrieval.html
`curl --silent -XGET http://169.254.169.254/latest/meta-data/public-ipv4`
end | [
"def aws_instance_ip\n `curl --silent -XGET http://169.254.169.254/latest/meta-data/local-ipv4`\n end",
"def my_public_ip\n if @my_public_ip\n @my_public_ip\n else\n #Use AWS instance data if available\n ip = `curl -s http://instance-data/latest/meta-data/public-ipv4... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add host in the specified groups. ==== Attributes +host+ Hostname +groups+ Groups to assign ==== Examples add_groups('pa2web01', ['local', 'web']) add_groups('pa2sql01', ['local', 'mysql', 'heartbeat']) | def add_groups(host, groups=[])
for group in groups
if !GROUPS.key?(group) then
GROUPS[group] = []
end
GROUPS[group].push(host)
end
end | [
"def add_host_to_group(host_id, group_id)\n message = {\n 'method' => 'hostgroup.massAdd',\n 'params' => {\n 'groups' => [ {'groupid' => group_id} ],\n 'hosts' => [ {'hostid' => host_id} ]\n }\n }\n\n group_request(message)\n end",
"def add_host(data)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add disk to the virtual machine ==== Attributes +server+ Server object +size+ Disk size in bytes ==== Examples add_disk(server, 5) Add a 5GB disk add_disk(server, 10) Add a 10GB disk | def add_disk(server, size)
host = server.to_s
# Increment disk id
if !DISKS.key?(host) then
DISKS[host] = 0
else
DISKS[host] += 1
end
disk_id = DISKS[host]
disk_filename = ".vagrant/disks/" + host + "_" + disk_id.to_s + ".vdi"
server.vm.provider "virtualbox" do |v|
# Create disk if it not exist
unless File.exist?(disk)
v.customize ["createhd", "--filename", disk_filename, "--size", size * 1024 * 1024]
end
v.customize ['storageattach', :id, '--storagectl', 'SATA Controller', '--port', disk_id, '--device', 0, '--type', 'hdd', '--medium', disk]
end
end | [
"def add_hdd_to_vbox_vm(client_name,vbox_disk_name)\n message = \"Attaching:\\tStorage to VM \"+client_name\n command = \"VBoxManage storageattach \\\"#{client_name}\\\" --storagectl \\\"#{$vbox_disk_type}\\\" --port 0 --device 0 --type hdd --medium \\\"#{vbox_disk_name}\\\"\"\n execute_command(message,command)\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /membership_contributions GET /membership_contributions.json | def index
@membership_contributions = MembershipContribution.all
end | [
"def contributions_made\n render json: @user.contributions\n end",
"def get_contributions(repository)\n Git.contributions GithubAPI.name(@username), repository\n end",
"def index\r\n @contributions = @person.contributions\r\n end",
"def month_contributions\r\n # Query contributions only if ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /membership_contributions POST /membership_contributions.json | def create
# byebug
@membership_contribution = MembershipContribution.new(membership_contribution_params)
@membership = MembershipBalance.find_by(params[:membership_id])
respond_to do |format|
if @membership_contribution.save
@a = MembershipContribution.all.last
# @balance = MembershipBalance.find(params)
@amount1 = @membership.balance + @a.amount
@b = MembershipBalance.where(membership_id: @a.membership_id).update_all(balance: @amount1)
format.html { redirect_to @membership_contribution, notice: 'Membership contribution was successfully created.' }
format.json { render :show, status: :created, location: @membership_contribution }
else
format.html { render :new }
format.json { render json: @membership_contribution.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @contribution = current_user.contributions.build(contribution_params)\n respond_to do |format|\n \n if @contribution.save\n format.html { redirect_to contributions_path, notice: '新規投稿が完了しました。' }\n format.json { render :show, status: :created, location: @contribution }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /membership_contributions/1 PATCH/PUT /membership_contributions/1.json | def update
respond_to do |format|
if @membership_contribution.update(membership_contribution_params)
format.html { redirect_to @membership_contribution, notice: 'Membership contribution was successfully updated.' }
format.json { render :show, status: :ok, location: @membership_contribution }
else
format.html { render :edit }
format.json { render json: @membership_contribution.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @membership.update_attributes membership_params\n respond_with @membership, location: edit_project_my_membership_url(@project)\n end",
"def update\n logger.info('PATCH Contribution JSON: ')\n logger.info(request_body)\n\n params = hashed_request\n if params[:cap_profile_id].blank?... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /membership_contributions/1 DELETE /membership_contributions/1.json | def destroy
@membership_contribution.destroy
respond_to do |format|
format.html { redirect_to membership_contributions_url, notice: 'Membership contribution was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @api_v1_contribution.destroy\n respond_to do |format|\n format.html { redirect_to api_v1_contributions_url, notice: 'Contribution was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contribution.destroy\n respond_to do |format|\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return booking request list where your user ID is equal to the client ID on the booking = Requests you've made on spaces. | def my_booking_requests
my_booking_requests = CONNECTION.exec("SELECT id FROM bookings WHERE client_id='#{@user_id}'")
return my_booking_requests
end | [
"def all_booking_of_client\n\t\t@bookings = Booking.where(client_id: params[:client_id])\n\t\trender json: @bookings, status: 200\n\tend",
"def make_bookings\n remove_bad_booking_requests.map do |data|\n request = data, row = data[1], seats = data[2]..data[4] \n seats.select do |seat| \n invalid_sea... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /game_ratings GET /game_ratings.json | def index
@game_ratings = GameRating.all
end | [
"def ratings\n Birdman::Requester.get(\"shows/#{id}/seasons/#{season}/episodes/#{episode}/ratings\")\n end",
"def ratings(args = {})\n begin\n do_get(AppFigures::API::RATINGS, args)\n rescue Exception => e\n puts e.message\n puts e.backtrace\n end\n end",
"def index\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /game_ratings POST /game_ratings.json | def create
@game_rating = GameRating.new(game_rating_params)
respond_to do |format|
if @game_rating.save
format.html { redirect_to @game_rating, notice: 'Game rating was successfully created.' }
format.json { render :show, status: :created, location: @game_rating }
else
format.html { render :new }
format.json { render json: @game_rating.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @rating = Rating.new(rating_params)\n if @rating.save\n render json: @rating, status: 201\n else\n render json: @rating.errors, status: :unprocessable_entity\n end\n end",
"def rate\n puts film_rating_params\n\n film = Film.find(film_rating_params[:film_id])\n user = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /game_ratings/1 PATCH/PUT /game_ratings/1.json | def update
respond_to do |format|
if @game_rating.update(game_rating_params)
format.html { redirect_to @game_rating, notice: 'Game rating was successfully updated.' }
format.json { render :show, status: :ok, location: @game_rating }
else
format.html { render :edit }
format.json { render json: @game_rating.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @rating = Rating.find(params[:id])\n\n respond_to do |format|\n if @rating.update_attributes(params[:rating])\n format.json { render json: @rating, status: :ok, location: nil }\n else\n format.json { render json: @rating.errors, status: :unprocessable_entity }\n end\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /game_ratings/1 DELETE /game_ratings/1.json | def destroy
@game_rating.destroy
respond_to do |format|
format.html { redirect_to game_ratings_url, notice: 'Game rating was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @rating.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @rating = Rating.find(params[:id])\n @rating.destroy\n\n respond_to do |format|\n format.html { redirect_to ratings_url }\n format.json { head :ok }\n end\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /post316s/1 GET /post316s/1.xml | def show
@post316 = Post316.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @post316 }
end
end | [
"def show\n @post306 = Post306.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @post306 }\n end\n end",
"def show\n @post170 = Post170.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.x... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /post316s/new GET /post316s/new.xml | def new
@post316 = Post316.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @post316 }
end
end | [
"def new\n @post155 = Post155.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @post155 }\n end\n end",
"def new\n @post306 = Post306.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @post306 }\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /post316s POST /post316s.xml | def create
@post316 = Post316.new(params[:post316])
respond_to do |format|
if @post316.save
format.html { redirect_to(@post316, :notice => 'Post316 was successfully created.') }
format.xml { render :xml => @post316, :status => :created, :location => @post316 }
else
format.html { render :action => "new" }
format.xml { render :xml => @post316.errors, :status => :unprocessable_entity }
end
end
end | [
"def post(data, tags_in = {}) ; post_to nil, data, tags_in end",
"def create\n @post415 = Post415.new(params[:post415])\n\n respond_to do |format|\n if @post415.save\n format.html { redirect_to(@post415, :notice => 'Post415 was successfully created.') }\n format.xml { render :xml => @pos... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Place Order POST /orders Recurring order start from the day you place them Assuming Resturant sent belongs to the user region only | def create
order_params = (place_order_params)
order_params[:customer_id] = current_user.customer_id
@order = Order.new(order_params)
if @order.recurring?
if((Time.now + 1.hour).strftime('%H:%M:%S') <= (Time.parse(@order.place_date + ' ' + @order.timeslot.start)).strftime('%H:%M:%S') && !@order.completed? )
# Add the auto generated entry
@order.category = 'single'
@order.created_by = 'auto'
@order.save!
end
# Improve this
if Order.create!(order_params)
render json: @order, status: 201
else
render json: {'errors': ['Order can no be placed']}, status: :unprocessable_entity
end
else
if (Time.now + 1.hour <= Time.parse(@order.place_date + ' ' + @order.timeslot.start)) && @order.save!
render json: @order, status: 201
else
render json: {'errorrs': ['Order can not be placed']}, status: :unprocessable_entity
end
end
end | [
"def create_order\n post_request \"orders\"\n end",
"def schedule_order(order)\n # No scheduled orders yet.\n end",
"def create_order_with_future_release_date(status = 1)\n order = Order.new\n order.order_status_id = status\n order.pickup_date = '2015-12-31'\n order.order_date = Date.tod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update order || Category can not be changed || Placed date || Time slot can not be changed |All ids are replaced| PATCH/PUT /orders/1 Assuming Resturant sent belongs to the user region only | def update
if @order.single?
if( (Time.now + 1.hour <= Time.parse(@order.place_date + ' ' + @order.timeslot.start)) && (!@order.completed? ) && @order.update(update_order_params) )
render json: @order, status: 200
else
render json: {'errorrs': ['Order can not be updated']}, status: :unprocessable_entity
end
else
if(@order.update(update_order_params))
render json: @order, status: 200
else
render json: {'errorrs': ['Order can not be updated']}, status: :unprocessable_entity
end
end
end | [
"def update\n json_response(@order.update!(order_params))\n end",
"def update_order(order_id:,\n body:)\n new_api_call_builder\n .request(new_request_builder(HttpMethodEnum::PUT,\n '/v2/orders/{order_id}',\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get/order/customer_recurring_orders Gets All recurring order that are used to generate auto orders for a customer || Check status | def customer_recurring_orders
# 1 represents
@orders = Order.where(customer_id: current_user.customer_id, category: :recurring)
render json: @orders, status: 200
end | [
"def all_orders(options)\n request :account, :get, 'allOrders', options\n end",
"def fetch_customer_orders options={}\n url_options = \"/api/customer/#{system_id}/\"\n url_options += @customer_id.to_s\n url_options += \"/orders\"\n url_options += (\"/?\" + options.map{|k,v| \"#{k}=#{v}... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get/order/customer_single_orders Get all single order regardless they are manual or auto for a customer | def customer_single_orders
@orders = Order.where(customer_id: current_user.customer_id, category: :single)
render json: @orders, status: 200
end | [
"def fetch_customer_orders options={}\n url_options = \"/api/customer/#{system_id}/\"\n url_options += @customer_id.to_s\n url_options += \"/orders\"\n url_options += (\"/?\" + options.map{|k,v| \"#{k}=#{v}\"}.join(\"&\"))\n resp = send_request(@url + url_options)\n begin\n Hash.from_xml(resp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get/order/driver_recurring_orders Gets recurring order that are used to generate auto orders for a driver | def driver_recurring_orders
@orders = Timeslot.joins(:orders).where(orders: { category: :recurring}, timeslots: {region_id: current_user.driver.region_id})
render json: @orders, status: 200
end | [
"def list_orders(code)\n PsegRecurring::Order.new(@credentials).fetch_orders(code)\n end",
"def fetch_orders(code)\n begin\n response = RestClient.get(\n \"#{@environment}/pre-approvals/#{code}/payment-orders?email=#{@email}&token=#{@token}\", \n {\n content_type: ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get/order/driver_single_orders Get all single order regardless they are manual or auto for a driver | def driver_single_orders
@orders = Timeslot.joins(:orders).where(orders: { category: :single}, timeslots: {region_id: current_user.driver.region_id})
render json: @orders, status: 200
end | [
"def get_orders\n orders\n end",
"def get_all_orders\n @orders = Order.all\n\n @show_detail = true\n end",
"def get_auto_orders(opts = {})\n data, _status_code, _headers = get_auto_orders_with_http_info(opts)\n data\n end",
"def get_orders(product_id='', status='')\n timestamp = Tim... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
put/order/1 Mark a order as complete by driver | def mark_order_complete
order_params = (driver_order_params)
order_params[:payable_attributes][:driver_id] = current_user.customer_id
if @order.single?
if( (Time.now >= Time.parse(@order.place_date + ' ' + @order.timeslot.start) || true) && (@order.pending? ) && @order.update(order_params) )
render json: @order, status: 200
else
render json: {'errorrs': ['Order can not be completed']}, status: :unprocessable_entity
end
else
if(@order.update(order_params))
render json: @order, status: 200
else
render json: {'errorrs': ['Order can not be completed']}, status: :unprocessable_entity
end
end
end | [
"def order_complete!\n self.state = 'complete'\n self.completed_at = Time.zone.now\n update_inventory\n end",
"def complete_order\n order = self.pending_order\n order.completed = true\n order.amount = @po.sum(:amount)\n order.date = Time.now.to_s\n order.save\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
xroad_id may be either ClientId or ServerId. | def verify_xroad_instance(xroad_id)
logger.debug("Instance verification: #{xroad_id}")
unless @xroad_instance.eql?(xroad_id.xroad_instance)
raise t("request.incorrect_instance")
end
end | [
"def verify_xroad_instance(xroad_id)\n logger.debug(\"Instance verification: #{xroad_id}\")\n\n unless @xroad_instance.eql?(xroad_id.xroad_instance)\n raise t(\"request.incorrect_instance\")\n end\n end",
"def set_net_id(x)\n $test_logger.log(\"Serial net Id change. New net Id '#{x}'\")\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /agenciamadres/1 GET /agenciamadres/1.xml | def show
@agenciamadre = Agenciamadre.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @agenciamadre }
end
end | [
"def show\n @ag = Ag.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @ag }\n end\n end",
"def show\n @agua = Agua.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /agenciamadres/new GET /agenciamadres/new.xml | def new
@agenciamadre = Agenciamadre.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @agenciamadre }
end
end | [
"def new\n @ag = Ag.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @ag }\n end\n end",
"def new\n @relatestagiario = Relatestagiario.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @relatesta... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /agenciamadres POST /agenciamadres.xml | def create
@agenciamadre = Agenciamadre.new(params[:agenciamadre])
respond_to do |format|
if @agenciamadre.save
format.html { redirect_to(@agenciamadre, :notice => 'Agencia Madre fue creada satisfactoriamente.') }
format.xml { render :xml => @agenciamadre, :status => :created, :location => @agenciamadre }
else
format.html { render :action => "new" }
format.xml { render :xml => @agenciamadre.errors, :status => :unprocessable_entity }
end
end
end | [
"def generate_tags\n uri = URI.parse(\"https://api.thomsonreuters.com/permid/calais\")\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n post_body = []\n post_body << \"<Document><Body>\"\n # stip html\n post_body << ActionView::Base.full_sanitizer.sanitize(params... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get next yahrzeit date on or after "from" date | def next_yahrzeit_date(from=Date.today)
return unless death_date
# TODO: use Marlena rules
h_from = Hebruby::HebrewDate.new(from)
h_death = Hebruby::HebrewDate.new(death_date)
# yahrzeit date from year
h_yahrzeit = Hebruby::HebrewDate.new(h_death.day, h_death.month, h_from.year)
date = Date.jd(h_yahrzeit.jd)
if date < from
h_yahrzeit = Hebruby::HebrewDate.new(h_death.day, h_death.month, h_from.year+1)
date = Date.jd(h_yahrzeit.jd)
end
date
end | [
"def next_date(from_date = nil)\n return nil if blank?\n from_date ||= if Date.respond_to?(:current)\n Date.current\n else\n Date.today\n end\n from_date = from_date.to_date\n until self[from_date.wday]\n from_date = from_date.succ\n end\n from_date.dup\n end",
"def next_ya... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets attributes of the load balancer The following attributes can be set: CrossZoneLoadBalancing (enable/disable) ConnectionDraining (enable/disable and timeout) Idle Connection Timeouts Still requires: AccessLog configuration ==== Parameters lb_name Name of the ELB options 'ConnectionDraining': 'Enabled' whether to enable connection draining 'Timeout' max time to keep existing conns open before deregistering instances 'CrossZoneLoadBalancing': 'Enabled' whether to enable cross zone load balancing 'ConnectionSettings': 'IdleTimeout' time (in seconds) the connection is allowed to be idle (no data has been sent over the connection) before it is closed by the load balancer. ==== Returns response: body: 'ResponseMetadata': 'RequestId' Id of request | def modify_load_balancer_attributes(lb_name, options)
attributes = Fog::AWS.serialize_keys 'LoadBalancerAttributes', options
request(attributes.merge(
'Action' => 'ModifyLoadBalancerAttributes',
'LoadBalancerName' => lb_name,
:parser => Fog::Parsers::AWS::ELB::Empty.new
))
end | [
"def modify_load_balancer_attributes(lb_id, attributes)\n attributes = Fog::AWS.serialize_keys 'Attributes', attributes.map{ |property, value| { :Key => property, :Value => value } }\n request(attributes.merge(\n 'Action' => 'ModifyLoadBalancerAttributes',\n 'LoadBa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
repair the list this item belongs to | def repair_list
self.class.repair_list(list_scope)
end | [
"def repair_list\n model.repair_list(list_scope)\n end",
"def remove_from_reorder_list\n\t\tItem.where(id: params[:i_id]).first\n\t\t@reorder_items = Item.all.need_reorder.alphabetical.to_a\n\tend",
"def fix_dropped_items\n bad_path = nil\n @model.each do |model, path, iter|\n i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
reorder the list this item belongs to | def reorder_list(order)
self.class.repair_list(list_scope.merge(:order => order))
end | [
"def reorder_list(order)\n model.repair_list(list_scope.merge(:order => order))\n end",
"def reorder\n end",
"def remove_from_reorder_list\n\t\tItem.where(id: params[:i_id]).first\n\t\t@reorder_items = Item.all.need_reorder.alphabetical.to_a\n\tend",
"def reorder_items(playlist)\n # we hav... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find best matching competition race for category. Iterate through traits (weight, equipment, ages, gender, abilities) until there is a single match (or none). | def best_match_in(event)
logger.debug "Category#best_match_in #{name} in #{event.name}: #{event.categories.map(&:name).join(', ')}"
candidate_categories = event.categories
equivalent_match = candidate_categories.detect { |category| equivalent?(category) }
logger.debug "equivalent: #{equivalent_match&.name}"
return equivalent_match if equivalent_match
candidate_categories = candidate_categories.select { |category| weight == category.weight }
logger.debug "weight: #{candidate_categories.map(&:name).join(', ')}"
candidate_categories = candidate_categories.select { |category| equipment == category.equipment }
logger.debug "equipment: #{candidate_categories.map(&:name).join(', ')}"
candidate_categories = candidate_categories.select { |category| ages_begin.in?(category.ages) }
logger.debug "ages: #{candidate_categories.map(&:name).join(', ')}"
candidate_categories = candidate_categories.reject { |category| gender == "M" && category.gender == "F" }
logger.debug "gender: #{candidate_categories.map(&:name).join(', ')}"
candidate_categories = candidate_categories.select { |category| ability_begin.in?(category.abilities) }
logger.debug "ability: #{candidate_categories.map(&:name).join(', ')}"
return candidate_categories.first if candidate_categories.one?
return nil if candidate_categories.empty?
if junior?
junior_categories = candidate_categories.select { |category| category.junior? }
logger.debug "junior: #{junior_categories.map(&:name).join(', ')}"
return junior_categories.first if junior_categories.one?
if junior_categories.present?
candidate_categories = junior_categories
end
end
if masters?
masters_categories = candidate_categories.select { |category| category.masters? }
logger.debug "masters?: #{masters_categories.map(&:name).join(', ')}"
return masters_categories.first if masters_categories.one?
if masters_categories.present?
candidate_categories = masters_categories
end
end
# E.g., if Cat 3 matches Senior Men and Cat 3, use Cat 3
# Could check size of range and use narrowest if there is a single one more narrow than the others
candidate_categories = candidate_categories.reject { |category| category.all_abilities? }
logger.debug "reject wildcards: #{candidate_categories.map(&:name).join(', ')}"
return candidate_categories.first if candidate_categories.one?
return nil if candidate_categories.empty?
# "Highest" is lowest ability number
highest_ability = candidate_categories.map(&:ability_begin).min
if candidate_categories.one? { |category| category.ability_begin == highest_ability }
highest_ability_category = candidate_categories.detect { |category| category.ability_begin == highest_ability }
logger.debug "highest ability: #{highest_ability_category.name}"
return highest_ability_category
end
candidate_categories = candidate_categories.reject { |category| gender == "F" && category.gender == "M" }
logger.debug "exact gender: #{candidate_categories.map(&:name).join(', ')}"
return candidate_categories.first if candidate_categories.one?
return nil if candidate_categories.empty?
logger.debug "no wild cards: #{candidate_categories.map(&:name).join(', ')}"
return candidate_categories.first if candidate_categories.one?
return nil if candidate_categories.empty?
raise "Multiple matches #{candidate_categories.map(&:name)} for #{name} in #{event.categories.map(&:name).join(', ')}"
end | [
"def find_by_category\n if @abv && @ibu\n find_by_abv_and_ibu(category: @category)\n elsif @abv\n find_by_abv(category: @category)\n elsif @ibu\n find_by_ibu(category: @category)\n else\n found_beer = Beer.where(category: @category).sample until found_beer\n fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
of sniff Version of the sniffer that uses multiple threads, may be better for bursty but otherwise low traffic environments. | def sniff_queue
queue = Queue.new
# Spin up a thread that just queues packets (a buffer, if you will)
qthread = Thread.new do
@sniffer.each_packet do |pkt|
queue.push pkt unless queue.length > 1000
end
end # of qthread
# Now read each of those packets
loop do
pkt = queue.pop
@event_collector.pkt_count += 1
@event_collector.bytes += pkt.caplen
case pkt
when @tcp_traffic
@tcp_handler.packet(pkt) if @tcp_handler
when @udp_traffic
@udp_handler.packet(pkt) if @udp_handler and pkt.udp? # INVESTIGATE!
end
end # of each_packet
end | [
"def sock\n\tself.scanner_socks ||= {}\n\tself.scanner_socks[Thread.current.to_s]\nend",
"def test_threading_non_keepalive\n d = create_driver(CONFIG_THREADING_NON_KEEPALIVE)\n d.end_if{ @posted.size == 3 }\n d.run(default_tag: 'test.metrics') do\n d.feed({ 'field1' => 50, 'field2' => 20, 'field3' =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
of packet() If the sequence number is valid, update the stream attributes. If not, perform the appropriate response but don't update the stream. Return true if valid and should continue parsing, false if it shouldn't, and a pkt if there is a queued next packet that needs to be injected into the stream. | def validate_sequence_numbers(pkt, state, dir)
expected_seq = dir == :up ? state.seq_up : state.seq_down
# If we don't have an expected sequence number yet, set one
expected_seq = pkt.tcp_seq if expected_seq == 0
# If we did not expect this sequence number, handle dissonance
if pkt.tcp_seq != expected_seq
return nil if pkt.tcp_seq < expected_seq # OS would ignore this packet
# The sequence number is high - save it for later?
if pkt.tcp_seq - expected_seq < FORWARD_WINDOW
segments = dir == :up ? state.segments_up : state.segments_down
segments[pkt.tcp_seq] = pkt
else # This packet is too far in advance, we're aborting on this steram
@event_collector.send(:tcp_stream_end) do
{ :syn_seen => !!state.syn_seen,
:src_ip => @protos.str_ip(pkt.src.to_i),
:dst_ip => @protos.str_ip(pkt.dst.to_i), :src_port => pkt.sport,
:dst_port => pkt.dport, :rst => false,
:fin => false, :sync => true, :timeout => false }
end
@protos.conclude(state, :up) # Kill the stream in both directions
@protos.conclude(state, :down)
state.app_state = nil # not parsing anymore
#delete_state(state) # don't delete the state, FIN/RST will do it.
end
return nil # in either case, we don't process the packet right now
# Sequence number was what we expected, this is part of our stream
else
# If this was a SYN packet, increase next expected sequence number by 1
# as specified by the TCP RFC.
expected_seq += 1 if pkt.tcp_syn?
# Adjust our next expected sequence number
if dir == :up
state.seq_up = (expected_seq + pkt.tcp_data_len) % 4294967296
else
state.seq_down = (expected_seq + pkt.tcp_data_len) % 4294967296
end
# Do we have a queued packet that we received out of order?
segments = dir == :up ? state.segments_up : state.segments_down
if segments.length > 0
queued_pkt = segments[expected_seq]
segments.reject! { |k,_| k <= expected_seq } # delete all passed segs
if queued_pkt
return queued_pkt
end
end # of if segments.length > 0
end
true
end | [
"def valid?\n \n #If we have a checksum field, then check it against the computed checksum.\n if respond_to?(:checksum)\n checksum.force_encoding('UTF-8') == computed_checksum.force_encoding('UTF-8')\n #Otherwise, assume the packet is valid.\n else\n true\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /wishes/new GET /wishes/new.json | def new
@wish = Wish.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @wish }
end
end | [
"def new\n @wish_item = WishItem.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @wish_item }\n end\n end",
"def new\n @wishlistitem = Wishlistitem.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /wishes POST /wishes.json | def create
@wish = current_user.wishes.build(params[:wish])
if @wish.save
flash[:success] = "Wish created!"
redirect_to root_url
else
@feed_items = []
render 'static_pages/home'
end
end | [
"def create\n @wish = Wish.new(params[:wish])\n\n respond_to do |format|\n if @wish.save\n format.html { redirect_to @wish, :notice => 'Wish was successfully created.' }\n format.json { render :json => @wish, :status => :created, :location => @wish }\n else\n format.html { rende... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /wishes/1 PUT /wishes/1.json | def update
@wish = Wish.find(params[:id])
respond_to do |format|
if @wish.update_attributes(params[:wish])
format.html { redirect_to @wish, notice: 'Wish was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @wish.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @wish = Wish.find(params[:id])\n\n respond_to do |format|\n if @wish.update_attributes(params[:wish])\n format.html { redirect_to @wish, :notice => 'Wish was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /aktions/1 GET /aktions/1.xml | def show
@aktion = Aktion.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @aktion }
end
end | [
"def index\n @aktions = @scope.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @aktions }\n end\n end",
"def index\n @kontakties = Kontakty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /aktions/new GET /aktions/new.xml | def new
@aktion = Aktion.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @aktion }
end
end | [
"def new\n @annonce = Annonce.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @annonce }\n end\n end",
"def new\n @atom = Atom.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @atom }\n end\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /aktions POST /aktions.xml | def create
@aktion = Aktion.new(params[:aktion])
respond_to do |format|
if @aktion.save
flash[:notice] = 'Aktion was successfully created.'
format.html { redirect_to(@aktion) }
format.xml { render :xml => @aktion, :status => :created, :location => @aktion }
else
format.html { render :action => "new" }
format.xml { render :xml => @aktion.errors, :status => :unprocessable_entity }
end
end
end | [
"def create\n @kontakt = Kontakt.new(kontakt_params)\n\n respond_to do |format|\n if @kontakt.save\n format.html { redirect_to @kontakt, notice: 'Kontakt was successfully created.' }\n format.json { render :show, status: :created, location: @kontakt }\n else\n format.html { rend... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PUT /aktions/1 PUT /aktions/1.xml | def update
@aktion = Aktion.find(params[:id])
respond_to do |format|
if @aktion.update_attributes(params[:aktion])
flash[:notice] = 'Aktion was successfully updated.'
format.html { redirect_to(@aktion) }
format.xml { head :ok }
else
format.html { render :action => "edit" }
format.xml { render :xml => @aktion.errors, :status => :unprocessable_entity }
end
end
end | [
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post 'update', opts\n end",
"def update opts = {}\n opts[:headers] ||= {}\n opts[:headers]['Content-Type'] ||= 'text/xml'\n post opts.fetch(:path, update_path), opts\n end",
"def put_entry(id,summ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /aktions/1 DELETE /aktions/1.xml | def destroy
@aktion = Aktion.find(params[:id])
@aktion.destroy
respond_to do |format|
format.html { redirect_to(aktions_url) }
format.xml { head :ok }
end
end | [
"def destroy\n @zakaz1 = Zakaz1.find(params[:id])\n @zakaz1.destroy\n\n respond_to do |format|\n format.html { redirect_to(zakaz1s_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @transaction_xml = Transaction::Xml.find(params[:id])\n @transaction_xml.destroy\n\n res... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets flag to make create/update account the default account | def add_default_account(post)
post[:defaultacct] = 'Y'
end | [
"def account_set_default(optname, optarg)\n Tw::Conf['default_user'] = optarg\n Tw::Conf.save()\n self.renderer.puts(\"set default user \\\"@#{Tw::Conf['default_user']}\\\"\")\n return 0\n end",
"def find_or_set_default_account\n # FIXME: API clients are scoped to their account so th... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds profile to post and sets update flag | def add_profile(post, profile)
post[:profile] = profile
post[:profileupdate] = 'Y'
end | [
"def add_profile(member)\n filter_profiles.create(profile: member, is_approved: true)\n end",
"def save\n overwrite @api.put('/profile.json',\n 'name' => name,\n 'timezone' => timezone,\n 'email' => email\n )\n end",
"def add_to_profile(profile_name:, profile_data:)\n Fara... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses profileid and acctid from profile, and adds it parameters, used for profile deletion | def add_profile_parameters(parameters, profile)
profileid, acctid = profile.split('/')
parameters[:profileid] = profileid
parameters[:acctid] = acctid
end | [
"def create_DB_profile\n \n @profile = ProfileId.new\n @profile.user_name = params[:user_name]\n @profile.profile_id = @parsed[\"profileId\"]\n @profile.save\n end",
"def add_profile(opts)\n opts = check_params(opts,[:profiles])\n super(opts)\n end",
"def add_profile(pos... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /list_invites/1 DELETE /list_invites/1.json | def destroy
@list_invite.destroy
respond_to do |format|
format.html { redirect_to list_invites_url }
format.json { head :no_content }
end
end | [
"def destroy\n @invite_list = InviteList.find(params[:id])\n @invite_list.destroy\n\n respond_to do |format|\n format.html { redirect_to invite_lists_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @invite = Invite.find(params[:id])\n @invite.destroy\n\n respo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the permissions associated with the role | def permissions
Roles.type_map[role_type].permissions
end | [
"def role_permissions\n return @role_permissions\n end",
"def permissions\n Roles.type_map[role_type.first].permissions\n end",
"def permissions\n if @permissions.nil?\n perm_array = []\n roles.each { |r| perm_array << r.permission_ids }\n @per... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the nearest timeframe | def set_time_frame time, time_slot = 30.minutes
Time.at(((time.to_i / time_slot).round * time_slot) + time_slot).to_i
end | [
"def timeframe=(val)\n raise(ArgumentError, 'timeframe value must be in the days_ago_list') unless days_ago_list.include? val\n\n @timeframe = val\n refresh_data\n\n end",
"def set_default_times\n if !self.start\n return\n end\n\n if self.start.hour == 0 # hour set to 0 if not othe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the recipe classes in order based on the Gemfile order | def ordered_recipes
return @ordered_recipes if @ordered_recipes
names = Bundler.load.dependencies.map(&:name)
# Setup a hash with the recipe name and the recipe class
recipe_pool = recipes.dup.inject({}) {|memo,recipe| memo[recipe.gem_name] = recipe ; memo }
# Go through the gems in the order they are in the Gemfile, then
# add them to the ordered list
@ordered_recipes = []
names.each do |name|
if recipe_pool[name]
@ordered_recipes << recipe_pool[name]
recipe_pool.delete(name)
end
end
# Add the remaining recipes (load them after everything else)
@ordered_recipes += recipe_pool.values
return @ordered_recipes
end | [
"def full_class_list\r\n v = first_last_versions\r\n packages.collect { |pkg|\r\n pkg.classes.collect { |c| c.to_full_qualified_s(v[0], v[1]) }\r\n }.flatten.sort{|a,b| a.casecmp b }\r\n end",
"def cookbook_order\n @cookbook_order ||= begin\n ordered_cookbooks = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the list of classes that match the current list of roles in the correct run order | def recipe_classes_with_roles(roles)
# Check to make sure some recipes have been added
if ordered_recipes.size == 0
raise Thor::InvocationError, 'no recipes have been defined'
end
if (roles.is_a?(Array) && roles.size == 0) || roles == :all
# Use all classes
role_classes = ordered_recipes
else
# Remove classes that don't fit the roles being used
role_classes = ordered_recipes.reject do |recipe_class|
![roles].flatten.map(&:to_s).include?(recipe_class.class_role)
end
end
end | [
"def classes\n if role\n return [role] unless @classes\n @classes << role unless @classes.include?(role)\n end\n\n @classes\n end",
"def roles_enabled\n migrate_roles\n\n hiera = hiera_load\n return [] unless hiera.key?('classes')\n\n roles = hiera['classes'].ma... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Invokes all recipes that implement the passed in role | def invoke_roles(task_name, roles, options={})
role_classes = self.recipe_classes_with_roles(roles)
# Run the taks on each role class
role_classes.each do |recipe_class|
# This class matches the role, so we should run it
recipe = recipe_class.new([], options)
task = recipe_class.tasks[task_name.to_s]
recipe.invoke_task(task)
# Copy back and updated options
options = recipe.options
end
end | [
"def recipe_from_role(name)\n role = Chef::Search::Query.new.search(:role, \"name:#{name}\")[0][0]\n if role.nil?\n fail \"Search for #{name} failed. Has the role been created?\"\n end\n\n run_list = role.env_run_list[chef_environment]\n run_list.select { |rli| rli.type ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /air_moistures GET /air_moistures.json | def index
@air_moistures = AirMoisture.all
end | [
"def index\n @armors = Armor.all\n\n render json: @armors\n end",
"def index\n @air_qualities = AirQuality.all\n\n render json: @air_qualities\n end",
"def index\n @airlines = Airline.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @airlin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /air_moistures POST /air_moistures.json | def create
@air_moisture = AirMoisture.new(air_moisture_params)
respond_to do |format|
if @air_moisture.save
format.html { redirect_to @air_moisture, notice: 'Air moisture was successfully created.' }
format.json { render :show, status: :created, location: @air_moisture }
else
format.html { render :new }
format.json { render json: @air_moisture.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @air = Air.new(params[:air])\n\n respond_to do |format|\n if @air.save\n format.html { redirect_to @air, :notice => 'Air was successfully created.' }\n format.json { render :json => @air, :status => :created, :location => @air }\n else\n format.html { render :actio... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.