query
stringlengths 7
9.5k
| document
stringlengths 10
1.07M
| negatives
listlengths 19
19
| metadata
dict |
|---|---|---|---|
GET /party_lists GET /party_lists.json
|
def index
@party_lists = PartyList.all.order(:id)
end
|
[
"def lists\n\t\tlistable = Listable.find_by_id(params['listable_id'])\n\t\tunless listable\n\t\t\trender :json => 'not found' , :status => :not_found\n\t\t\treturn\n\t\tend\n\t\tlists = List.where :name => listable.name\t\n\t\trender :json => lists.to_json\n\tend",
"def get_list(list_id:)\n JSON.parse(api_request(method: :get, path: \"lists/#{list_id}\"))\n end",
"def create\n @party_list = PartyList.new(party_list_params)\n\n respond_to do |format|\n if @party_list.save\n format.html { redirect_to @party_list, notice: 'Party list was successfully created.' }\n format.json { render :show, status: :created, location: @party_list }\n else\n format.html { render :new }\n format.json { render json: @party_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @rock_parties = RockParty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @rock_parties }\n end\n end",
"def index\n @parties = Party.all.order(:name)\n respond_with(@parties) do |format|\n format.to_json { @parties.to_json(:include => :guests) }\n format.html\n end\n end",
"def index\n @party_profiles = PartyProfile.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @party_profiles }\n end\n end",
"def index\n @party_records = PartyRecord.order(\"partySet_id, testident, surname, forename\")\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @party_records }\n end\n end",
"def index\n @fdn_party_orgs = Fdn::PartyOrg.all\n end",
"def get_lists(user)\n get(\"/#{user}/lists.json\")\n end",
"def party\n @party_id = params[:party_id]\n\n # Initialize Stream client with your api key and secret\n @stream_client = Generic.get_streams_client\n\n # Instantiate Stream user feed object\n @user_feed = @stream_client.feed('party', @party_id)\n\n # Get Flat activities \n result = @user_feed.get(:limit=>10)\n\n result[\"results\"].each_with_index do |item, index|\n @user_party_id = @party_id\n\n # Get user party\n @party_name = Party.where(id: @user_party_id).pluck(:name).first\n result[\"results\"][index][\"party\"] = @party_name\n end\n\n render json: result[\"results\"], status: :ok\n end",
"def index\n @party_names = PartyName.all\n end",
"def index\n @parties = Party.all\n end",
"def index\n @partners = Partner.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @partners }\n end\n end",
"def update\n respond_to do |format|\n if @party_list.update(party_list_params)\n format.html { redirect_to @party_list, notice: 'Party list was successfully updated.' }\n format.json { render :show, status: :ok, location: @party_list }\n else\n format.html { render :edit }\n format.json { render json: @party_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @party_members = PartyMember.all\n end",
"def index\n @crew_parties = Crew::Party.all\n end",
"def index\n @girls_parties = GirlsParty.all\n end",
"def get_list(list)\n api_get(:list, {:list => list})\n end",
"def index\n @interested_parties = InterestedParty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @interested_parties }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /party_lists POST /party_lists.json
|
def create
@party_list = PartyList.new(party_list_params)
respond_to do |format|
if @party_list.save
format.html { redirect_to @party_list, notice: 'Party list was successfully created.' }
format.json { render :show, status: :created, location: @party_list }
else
format.html { render :new }
format.json { render json: @party_list.errors, status: :unprocessable_entity }
end
end
end
|
[
"def create_list(name:)\n JSON.parse(api_request(method: :post, path: \"lists\", params: list_params(name)))\n end",
"def update\n respond_to do |format|\n if @party_list.update(party_list_params)\n format.html { redirect_to @party_list, notice: 'Party list was successfully updated.' }\n format.json { render :show, status: :ok, location: @party_list }\n else\n format.html { render :edit }\n format.json { render json: @party_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @partner_list = PartnerList.new(partner_list_params)\n\n respond_to do |format|\n if @partner_list.save\n format.html { redirect_to @partner_list, notice: 'Partner list was successfully created.' }\n format.json { render :show, status: :created, location: @partner_list }\n else\n format.html { render :new }\n format.json { render json: @partner_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_to_list\n lists = List.find(params[:person_to_list_id])\n person = Person.find(params[:person][:id])\n person.lists << lists\n\n redirect_to root_url\n end",
"def create\n @rock_party = RockParty.new(params[:rock_party].merge(user: current_user))\n\n # Add attendees to rock party\n if params[:attendees]\n params[:attendees].each do |user_id|\n user = User.find(user_id)\n @rock_party.users << user\n end\n end\n\n respond_to do |format|\n if @rock_party.save\n format.html { redirect_to @rock_party, notice: 'Rock party was successfully created.' }\n format.json { render json: @rock_party, status: :created, location: @rock_party }\n else\n format.html { render action: \"new\" }\n format.json { render json: @rock_party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @follow_list = FollowList.new(follow_list_params)\n\n respond_to do |format|\n if @follow_list.save\n format.html { redirect_to @follow_list, notice: 'Follow list was successfully created.' }\n format.json { render :show, status: :created, location: @follow_list }\n else\n format.html { render :new }\n format.json { render json: @follow_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @named_list = NamedList.new(named_list_params)\n\n respond_to do |format|\n if @named_list.save!\n format.html { redirect_to named_lists_url, notice: 'Named list was successfully created.' }\n format.json { render :show, status: :created, location: @named_list }\n else\n format.html { render :new }\n format.json { render json: @named_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @rental_list = current_user.rental_lists.new(rental_list_params)\n\n respond_to do |format|\n if @rental_list.save\n format.html { redirect_to rental_lists_path, notice: 'Rental list was successfully created.' }\n format.json { render :show, status: :created, location: @rental_list }\n else\n format.html { render :new }\n format.json { render json: @rental_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_list(name, source, opt_in_type)\n endpoint = \"/api/v1/list/create/\"\n base_params = base_params(endpoint)\n custom_params = {\n \"name\" => name,\n \"source\" => source,\n \"opt_in_type\" => opt_in_type\n }\n uri = post_api_uri(endpoint)\n http = setup_request(uri)\n result = http.post(uri.path, base_params.merge(custom_params).to_query)\n JSON.parse(result.body)\n end",
"def create\n @wellist = Wellist.new(wellist_params)\n\n if @wellist.save\n render json: @wellist, status: :created, location: @wellist\n else\n render json: @wellist.errors, status: :unprocessable_entity\n end\n end",
"def create\n @saved_list = SavedList.new\n @saved_list.login_id = params[:login_id]\n @saved_list.list_name = params[:list_name]\n @saved_list.saved_user_list = true\n @saved_list.date_saved = params[:date_saved]\n\n respond_to do |format|\n if @saved_list.save\n\n @user_ids = params[\"user_ids\"]\n @user_ids.each do |user_id|\n SavedListUser.create(saved_list_id: @saved_list.id, user_id: user_id)\n end\n\n format.html { redirect_to @saved_list, notice: 'Saved list was successfully created.' }\n format.json { render :show, status: :created, location: @saved_list }\n else\n format.html { render :new }\n format.json { render json: @saved_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_party(new_party)\n# add the new party to the array\n @list << new_party\n# make the new party the last entry in the array\n @list.last\n end",
"def destroy\n @party_list.destroy\n respond_to do |format|\n format.html { redirect_to party_lists_url, notice: 'Party list was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def index\n @party_lists = PartyList.all.order(:id)\n end",
"def create\n @responsible_party = ResponsibleParty.new(responsible_party_params)\n\n respond_to do |format|\n if @responsible_party.save\n format.html { redirect_to @responsible_party, notice: 'Responsible party was successfully created.' }\n format.json { render :show, status: :created, location: @responsible_party }\n else\n format.html { render :new }\n format.json { render json: @responsible_party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_wundercoach_list\n response = request.lists.create({\n body: {\n name: 'Wundercoach',\n permission_reminder: 'You booked an event at wundercoach.net',\n use_archive_bar: false,\n campaign_defaults: {\n from_name: account.name,\n from_email: account.email,\n language: 'de',\n subject: 'Newsletter'\n },\n contact: account.mailchimp_contact_data,\n email_type_option: false,\n visibility: 'prv'\n }\n })\n response['id']\n end",
"def create\n @house_interest_list = HouseInterestList.new(house_interest_list_params)\n @house_interest_list.user_id = session[:id]\n @house_interest_list.company_id = House.find(@house_interest_list.house_id).company_id\n \n respond_to do |format|\n if @house_interest_list.save\n format.html {redirect_to @house_interest_list, notice: 'House interest list was successfully created.'}\n format.json {render :show, status: :created, location: @house_interest_list}\n else\n format.html {render :new}\n format.json {render json: @house_interest_list.errors, status: :unprocessable_entity}\n end\n end\n end",
"def create\n @twitter_list = TwitterList.new(params[:twitter_list])\n\n respond_to do |format|\n if @twitter_list.save\n format.html { redirect_to @twitter_list, notice: 'Twitter list was successfully created.' }\n format.json { render json: @twitter_list, status: :created, location: @twitter_list }\n else\n format.html { render action: \"new\" }\n format.json { render json: @twitter_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(name)\n Iterable.request(conf, '/lists').post(name: name)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PATCH/PUT /party_lists/1 PATCH/PUT /party_lists/1.json
|
def update
respond_to do |format|
if @party_list.update(party_list_params)
format.html { redirect_to @party_list, notice: 'Party list was successfully updated.' }
format.json { render :show, status: :ok, location: @party_list }
else
format.html { render :edit }
format.json { render json: @party_list.errors, status: :unprocessable_entity }
end
end
end
|
[
"def update_list(list_id:, name:)\n api_request(method: :patch, path: \"lists/#{list_id}\", params: list_params(name))\n end",
"def update\n @party = current_user.parties.find(params[:id])\n\n respond_to do |format|\n if @party.update_attributes(params[:party])\n format.html { redirect_to @party, notice: 'Party was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @party_set = PartySet.find(params[:id])\n\n respond_to do |format|\n if @party_set.update_attributes(params[:party_set])\n format.html { redirect_to @party_set, notice: 'Party set was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @party_set.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @interested_party = InterestedParty.find(params[:id])\n\n respond_to do |format|\n if @interested_party.update_attributes(params[:interested_party])\n format.html { redirect_to(@interested_party, :notice => 'Interested party was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @interested_party.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_with @todo_list.update(todo_list_params)\n end",
"def update\n respond_to do |format|\n if @partner_list.update(partner_list_params)\n format.html { redirect_to @partner_list, notice: 'Partner list was successfully updated.' }\n format.json { render :show, status: :ok, location: @partner_list }\n else\n format.html { render :edit }\n format.json { render json: @partner_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @political_party.update(political_party_params)\n format.html { redirect_to @political_party, notice: 'Political party was successfully updated.' }\n format.json { render :show, status: :ok, location: @political_party }\n else\n format.html { render :edit }\n format.json { render json: @political_party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @follow_list.update(follow_list_params)\n format.html { redirect_to @follow_list, notice: 'Follow list was successfully updated.' }\n format.json { render :show, status: :ok, location: @follow_list }\n else\n format.html { render :edit }\n format.json { render json: @follow_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @responsible_party.update(responsible_party_params)\n format.html { redirect_to @responsible_party, notice: 'Responsible party was successfully updated.' }\n format.json { render :show, status: :ok, location: @responsible_party }\n else\n format.html { render :edit }\n format.json { render json: @responsible_party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @pokeparty = Pokeparty.find(params[:id])\n\n respond_to do |format|\n if @pokeparty.update_attributes(params[:pokeparty])\n format.html { redirect_to @pokeparty, notice: 'Pokeparty was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pokeparty.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n item = @list.list_items.find(params[:id])\n\n if item.update_attributes(params[:list_item])\n render json: item\n else\n error(t('messages.list_item.errors.update'))\n end\n end",
"def update\n respond_to do |format|\n if @pick_list.update(pick_list_params)\n format.html { redirect_to @pick_list, notice: 'Pick list was successfully updated.' }\n format.json { render :show, status: :ok, location: @pick_list }\n else\n format.html { render :edit }\n format.json { render json: @pick_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @list_ownership = ListOwnership.find(params[:id])\n\n respond_to do |format|\n if @list_ownership.update_attributes(params[:list_ownership])\n format.html { redirect_to @list_ownership, notice: 'List ownership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @list_ownership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n respond_to do |format|\n if @political_party_master.valid?\n @political_party_master.party_initial = PoliticalPartyMaster.get_special_code(political_party_master_params[:name])\n logger.info \"party === #{ political_party_master_params[:party_initial].inspect}\"\n @political_party_master.update(political_party_master_params)\n format.html { redirect_to @political_party_master, notice: \"Political party master was successfully updated.\" }\n format.json { render :show, status: :ok, location: @political_party_master }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @political_party_master.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @third_party.update(third_party_params)\n format.html { redirect_to @third_party, notice: 'Party was successfully updated.' }\n format.json { render :show, status: :ok, location: @third_party }\n else\n format.html { render :edit }\n format.json { render json: @third_party.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @org_list = OrgList.find(params[:id])\n\n respond_to do |format|\n if @org_list.update_attributes(params[:org_list])\n format.html { redirect_to org_lists_path, notice: 'Org list was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @org_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @interest_list.update(interest_list_params)\n format.html { redirect_to @interest_list, notice: 'Interest list was successfully updated.' }\n format.json { render :show, status: :ok, location: @interest_list }\n else\n format.html { render :edit }\n format.json { render json: @interest_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @custom_list.update(custom_list_params)\n format.html { redirect_to @custom_list, notice: 'Custom list was successfully updated.' }\n format.json { render :show, status: :ok, location: @custom_list }\n else\n format.html { render :edit }\n format.json { render json: @custom_list.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @issue_list.update(issue_list_params)\n format.html { redirect_to @issue_list, notice: 'Issue list was successfully updated.' }\n format.json { render :show, status: :ok, location: @issue_list }\n else\n format.html { render :edit }\n format.json { render json: @issue_list.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /party_lists/1 DELETE /party_lists/1.json
|
def destroy
@party_list.destroy
respond_to do |format|
format.html { redirect_to party_lists_url, notice: 'Party list was successfully destroyed.' }
format.json { head :no_content }
end
end
|
[
"def destroy\n @party = Party.find(params[:id])\n @party.destroy\n\n respond_to do |format|\n format.html { redirect_to(parties_url) }\n format.json { head :ok }\n end\n end",
"def destroy\n @party = Party.find(params[:id])\n @party.destroy\n\n respond_to do |format|\n format.html { redirect_to parties_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @party_set = PartySet.find(params[:id])\n @party_set.destroy\n\n respond_to do |format|\n format.html { redirect_to party_sets_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @party = Partie.find(params[:id])\n @party.destroy\n\n respond_to do |format|\n format.html { redirect_to parties_url }\n format.json { head :no_content }\n end\n end",
"def delete_list(list)\n api_delete(:list, {:list => list})\n end",
"def delete_list(user, list)\n delete(\"/#{user}/lists/#{list}.json\")\n end",
"def destroy\n @party = Party.find(params[:id])\n @party.destroy\n\n respond_to do |format|\n format.html { redirect_to(parties_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @interested_party = InterestedParty.find(params[:id])\n @interested_party.destroy\n\n respond_to do |format|\n format.html { redirect_to(interested_parties_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @pokeparty = Pokeparty.find(params[:id])\n @pokeparty.destroy\n\n respond_to do |format|\n format.html { redirect_to pokeparties_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @house_list.destroy\n respond_to do |format|\n format.html { redirect_to house_lists_url }\n format.json { head :no_content }\n end\n end",
"def delete_list(list_id:)\n api_request(method: :delete, path: \"lists/#{list_id}\")\n end",
"def destroy\n @rock_party = RockParty.find(params[:id])\n @rock_party.destroy\n\n respond_to do |format|\n format.html { redirect_to rock_parties_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hold_list.destroy\n respond_to do |format|\n format.html { redirect_to hold_lists_url, notice: 'Hold list was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @party_name = PartyName.find(params[:id])\n @party_name.destroy\n\n respond_to do |format|\n format.html { redirect_to(party_names_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @party_name.destroy\n respond_to do |format|\n format.html { redirect_to party_names_url, notice: 'Party name was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @client_list = ClientList.find(params[:id])\n @client_list.destroy\n\n respond_to do |format|\n format.html { redirect_to(client_lists_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @adr_list.destroy\n respond_to do |format|\n format.html { redirect_to adr_lists_url, notice: \"Adr list was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @house_interest_list.destroy\n respond_to do |format|\n format.html {redirect_to house_interest_lists_url, notice: 'House interest list was successfully destroyed.'}\n format.json {head :no_content}\n end\n end",
"def destroy\n @opp_party.destroy\n respond_to do |format|\n format.html { redirect_to opp_parties_url, notice: 'Opp party was successfully destroyed.' }\n format.json { head :no_content }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Simple method to merge strings from freelancer skills
|
def merge_skills(skills, newSkill)
if newSkill!=""
skills = skills + " " + newSkill
end
return skills
end
|
[
"def full_name_with_skills\n self.full_name + ' ' + self.all_skills_with_hashtags\n end",
"def merica(str)\n # concatenating the strings\n str + \"only in America!\"\nend",
"def merge_word_strings str1, str2\n return str2||\"\" if str1.blank?\n return str1 if str2.blank?\n (str1.split(/\\s+/) + str2.split(/\\s+/)).uniq.join(' ')\nend",
"def artists_str\n headliners_str + supporting_acts_str\n end",
"def merge_word word\n self << \" #{word}\" unless split.include? word\n self\n end",
"def combine_strings(str1,str2)\n puts str1.concat(str2)\nend",
"def concat_names(contribs)\n contribs.map do |p|\n if p.name.surname\n \"#{p.name.surname}, #{p.name.forename.map(&:to_s).join(' ')}\"\n else\n p.name.completename.to_s\n end\n end.join(\" and \")\n end",
"def format_words(words)\n return \"\" if words.empty?\n return words.join if words.size <= 1\n words = words.join(\" \").split()\n ending = words.slice!(-2, 2).join(' and ')\n words.push(ending).join(', ')\nend",
"def snippet(text, wordcount, omission)\n text.split[0..(wordcount-1)].join(\" \") + (text.split.size > wordcount ? \" \" + omission : \"\")\n end",
"def all_skills_with_hashtags\n self.skills.map(&:name).collect{|name| '#' + name}.join(' ')\n end",
"def create_multi_name\n base_name = String.new(Faker::Games::ElderScrolls.creature)\n if base_name.split.size == 1\n adjective = Spicy::Proton.adjective.capitalize\n new_name = base_name.split.unshift(adjective)\n new_name.join(' ')\n else\n return base_name\n end\n end",
"def combine_strings(strings, conjunction = 'or')\n case strings.size\n when 0\n ''\n when 1\n strings[0]\n when 2\n \"#{strings[0]} #{conjunction} #{strings[1]}\"\n else\n \"#{strings[0...-1].join(', ')}, #{conjunction} #{strings.last}\"\n end\n end",
"def write_school_skills(school_skill, skill_list)\n this_skill = school_skill.skill.name_pl\n school_skill.skill_emphasis.present? ? this_skill += \" (#{school_skill.skill_emphasis})\" : \"\"\n school_skill.value != 1 ? this_skill += \" #{school_skill.value}\" : \"\"\n school_skill == skill_list.last ? this_skill : this_skill += \",\"\n end",
"def answer_join\n strings_joined = @data.map do |answer|\n answer.join(' ')\n end\n strings_joined[0] = strings_joined[0].gsub(\"QUIZ ANSWERS \", '')\n @data = strings_joined\n end",
"def generate_skills(skills)\n if skills.blank?\n return []\n end\n if skills.kind_of?(String)\n return skills.split(',').collect { |s| s.strip().downcase() };\n else\n return skills\n end\n end",
"def smash(words)\n sentence = \"\"\n for word in words #word- name that ruby refers to each element\n sentence = sentence + \" \" + word\n end\n return sentence.strip\nend",
"def sentence_maker(array_of_strings)\n result = \"\"\n last_word = array_of_strings.pop\n array_of_strings.each do |word|\n result += word.to_s + \" \"\n end\n result += last_word + \".\"\n return result.capitalize!\nend",
"def word_substituter(tweet)\n shortened = []\n\n tweet_words = tweet.split\n\n tweet_words.each do |word|\n short_form = dictionary(word.downcase)\n if short_form\n shortened << short_form\n else\n shortened << word\n end\n end\n\n shortened.join(' ')\nend",
"def add_strings(text1, text2)\n text1.to_s + ' ' + text2.to_s\nend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Use the Anemone page store to find the closest referer in the crawl tree that is a case (or nil if any URL in the chain can't be found)
|
def find_nearest_page_matching(url, regex)
raise ArgumentError,
'No crawl found. Set @crawl as the first thing in your Anemone.crawl block' if crawl.nil?
page = @crawl.pages[url]
return page if page.nil? || page.url.to_s =~ regex
find_nearest_page_matching(page.referer, regex)
end
|
[
"def find_next_url(page)\r\n raise 'Define me!'\r\n end",
"def find_linked_page( current_page, reference )\n\t\t\n\t\tcatalog = current_page.catalog\n\t\t\n\t\t# Lookup by page path\n\t\tif reference =~ /\\.page$/\n\t\t\treturn catalog.uri_index[ reference ]\n\t\t\t\n\t\t# Lookup by page title\n\t\telse\n\t\t\treturn catalog.title_index[ reference ]\n\t\tend\n\tend",
"def categorize_referer( referer, collapse = false )\n ret = nil\n return ret unless referer\n case referer\n when /\\/t.co\\// then ret = 'Twitter'\n when /\\/m.facebook.com/ then ret = 'Facebook'\n when /google/ then ret = 'Google'\n when /yahoo/ then ret = 'Yahoo'\n when /youtube/i then return ret\n else\n ret = URI.parse( referer ).host\n end\n ret = 'externalsites' if collapse\n ret\n end",
"def crawl\n # TODO flush the page cache. We cache the crawled pages.\n begin\n account_detail_page #This will get us as far as we want to go, through several pages\n rescue *ERRORS_TO_RESCUE_FROM => e\n errors[:message] = e.message\n errors[:page_url] = e.page.uri\n errors[:page_body] = e.page.body\n return nil\n end\n end",
"def find_url_of(app)\n visit{|path, visited| return path if app==visited}\n nil\n end",
"def next_site referrer = \"\"\n if valid_site? referrer\n idx = sites.index(URI(referrer))\n nxt = (idx + 1) % sites.size\n return sites[nxt]\n end\n\n return sites.sample\nend",
"def getFirstMatch page\n list = page.search('.findList')\n return nil if list.empty?\n return list.search('.findResult')[0].search('.result_text').children[1].attr('href')\nend",
"def correct_site()\n first_site = Nokogiri::HTML(open(@url))\n\n begin\n check_spelling = first_site.css(\"span.spell.ng\")[0].text\n rescue\n check_spelling = \"\"\n end\n\n if check_spelling != \"\"\n @url = \"https://www.google.com\" + first_site.css(\"span.spell.ng + a\")[0][\"href\"]\n return Nokogiri::HTML(open(@url))\n else\n return first_site\n end\n end",
"def parent_of( page )\n dir = page.directory\n\n loop do\n if @db.has_key? dir\n parent = @db[dir].find {|p| p.filename == 'index'}\n return parent unless parent.nil? or parent == page\n end\n\n break if dir.empty?\n dir = ::File.dirname(dir)\n dir = '' if dir == '.'\n end\n\n return\n end",
"def getAppropriatePage(page)\n if page.nil?\n return nil\n end\n\n bestPage = page\n if page.langcode != @langcode\n page.data['translations'].each { |langcode, translationPage|\n if translationPage.langcode == @langcode\n bestPage = translationPage\n break\n end\n }\n end\n\n bestPage\n end",
"def find_parents(this_page)\n trail = [this_page]\n if this_page.path.include?(\"/\")\n path = this_page.path\n while path.include?(\"/\")\n path, _, current = path.rpartition(\"/\")\n page_id = path\n page_id += \"/index\"\n trail << (find_resource(page_id) || path.rpartition(\"/\").last) unless current == \"index.html\"\n end\n\n end\n trail << find_resource(\"index\") unless this_page == find_resource(\"index\")\n trail.reverse\n end",
"def find_with_redirect(name)\n result = self.find_by_name(name)\n return result unless result.nil?\n redirects = Redirect.find_all_by_name(name)\n (redirect = redirects.select{|r| self === r.page }.first) && redirect.page\n end",
"def links_to_follow(page)\n unless options[:depth_limit] and page.depth >= options[:depth_limit]\n links = if @focus_crawl_block\n @focus_crawl_block.call(page)\n else\n page.links.select { |link| in_domain?(link, page) }\n end\n links.select { |link| visit_link?(link) }.uniq\n else\n [] # depth limit reached; don't follow any links\n end\n end",
"def crawl_site(url = @urls.first, &block)\n assert_type(url, Wgit::Url)\n\n doc = crawl_url(url, &block)\n return nil if doc.nil?\n\n host = url.to_base\n alt_url = url.end_with?('/') ? url.chop : url + '/'\n crawled = [url, alt_url]\n externals = doc.external_links\n internals = get_internal_links(doc)\n\n return doc.external_links.uniq if internals.empty?\n\n loop do\n crawled.uniq!\n internals.uniq!\n\n links = internals - crawled\n break if links.empty?\n\n links.each do |link|\n orig_link = link.dup\n doc = crawl_url(\n link, follow_external_redirects: false, host: host, &block\n )\n\n crawled.push(orig_link, link) # Push both in case of redirects.\n next if doc.nil?\n\n internals.concat(get_internal_links(doc))\n externals.concat(doc.external_links)\n end\n end\n\n externals.uniq\n end",
"def referrer_or_current_path\n referrer_path.blank? ? current_path : referrer_path\n end",
"def page_for_url(url)\n logger.debug(\"checking if this page url \" + self.url.to_s + \" == \" + url.to_s);\n if (self.url == url)\n logger.debug(\"true, match found\");\n return self\n else\n children.each do |child|\n if (url =~ Regexp.compile( '^' + Regexp.quote(child.url)))\n found = child.page_for_url(url)\n return found if found\n end\n end\n end\n return nil;\n end",
"def _find_common_parent_reverse entry_points, total_travel_time, conveyors, entry_point, target\n conveyor = conveyors.select {|cs| cs.node2 == entry_point}.first\n if conveyor\n if conveyor.node1 == target\n puts \"!!found common parent: #{target}\"\n return target\n else\n puts \"..keep looking: #{conveyor.node1}, #{target}\"\n _find_common_parent_reverse entry_points, total_travel_time, conveyors, conveyor.node1, target\n end\n end\n end",
"def referrer_code\n if referrer\n referrer.referral_code\n else\n nil\n end\n end",
"def referer\n headers['Referer'] ? Addressable::URI.parse(headers['Referer']) : nil\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
List milestones for a repository = Examples bitbucket = BitBucket.new :user => 'username', :repo => 'reponame' bitbucket.issues.milestones.list
|
def list(user_name, repo_name, params={})
_update_user_repo_params(user_name, repo_name)
_validate_user_repo_params(user, repo) unless user? && repo?
normalize! params
response = get_request("/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones", params)
return response unless block_given?
response.each { |el| yield el }
end
|
[
"def list_milestones(repository, options = T.unsafe(nil)); end",
"def fetch()\n puts \"+ Loading github milestones\".blue\n\n @milestones = GitHub.get \"#{REPO}/milestones\", :headers => {\"User-Agent\" => \"Jamoma issues migration\"}\n end",
"def milestones\n Sifter.\n get(api_milestones_url).\n fetch(\"milestones\", []).\n map { |m| Sifter::Milestone.new(m) }\n end",
"def milestone(repository, number, options = {})\n get \"#{Repository.path repository}/milestones/#{number}\", options\n end",
"def milestones_from_github()\n\tmilestones = {}\n\tgh_milestones = Octokit.list_milestones(GITHUB_REPO, :state => \"open\") +\n\t\t\tOctokit.list_milestones(GITHUB_REPO, :state => \"closed\")\n\tgh_milestones.each do |milestone|\n\t\tmilestones[milestone['title']] = milestone['number']\n\tend\n\treturn milestones\nend",
"def milestones\n @milestones ||= ApiFactory.new 'Issues::Milestones'\n end",
"def milestones(project_id, find = 'all')\n records \"milestone\", \"/projects/#{project_id}/milestones/list\", :find => find\n end",
"def milestones(project_id, find=\"all\")\n records \"milestone\", \"/projects/#{project_id}/milestones/list\", :find => find\n end",
"def milestones\n Milestone.find_all_by_project_id(id)\n end",
"def milestones\n names = self.milestone_names\n return [] if !names or !self.project # 24-Jul-2013: or !self.project because a request can be associated to a stream and no project\n self.project.milestones.select{|m| names.include?(m.name)}\n end",
"def get_milestones\n if params[:project_id].blank?\n render :text => \"\" and return\n end\n\n @milestones = Milestone.find(:all, :order => 'milestones.due_at, milestones.name', :conditions => ['company_id = ? AND project_id = ? AND completed_at IS NULL', current_user.company_id, params[:project_id]])\n @milestones = @milestones.map { |m| { :text => m.name.gsub(/\"/,'\\\"'), :value => m.id.to_s } }\n @milestones = @milestones.map { |m| m.to_json }\n @milestones = @milestones.join(\", \")\n\n res = '{\"options\":[{\"value\":\"0\", \"text\":\"' + _('[None]') + '\"}'\n res << \", #{@milestones}\" unless @milestones.nil? || @milestones.empty?\n res << '],'\n p = current_user.projects.find(params[:project_id]) rescue nil\n if p && current_user.can?(p, 'milestone')\n res << '\"add_milestone_visible\":\"true\"'\n else\n res << '\"add_milestone_visible\":\"false\"'\n end\n res << '}'\n\n render :text => \"#{res}\"\n end",
"def getMilestones(projectId, * queryMap)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"\r\n\t\t\t\tif queryMap.length == 0\r\n\t\t\t\t\tresponse = ZohoHTTPClient.get(url, getQueryMap)\r\n\t\t\t\telse\r\n\t\t\t\t\tresponse = ZohoHTTPClient.get(url, getQueryMap(queryMap))\r\n\t\t\t\tend\r\n\t\t\t\treturn $milestonesParser.getMilestones(response)\r\n\t\t\tend",
"def create_milestones(issues)\n # Create a list of issues with unique sprint names.\n uniq_issues = issues.uniq { |issue| issue[:sprint] }\n # Create an array of sprint names.\n sprints = uniq_issues.map { |issue| issue[:sprint] }\n # Remove any empty strings.\n sprints = sprints.reject { |sprint| sprint.nil? || sprint.empty? }\n\n # Iterate through each sprint name in the array.\n sprints.each do |sprint|\n # Search for all existing milestones in the project with the same name as the current sprint.\n existing_milestones = @gitlab.milestones(PROJECT_ID, options: { search: \"#{sprint}\" } )\n\n # Create a list of existing milestones.\n existing_milestones_array = []\n existing_milestones.auto_paginate do |_milestone|\n existing_milestones_array << _milestone.to_hash\n end\n\n # Select any milestone with the same title as the current sprint.\n existing_sprint = existing_milestones_array.select do |_milestone|\n next(_milestone.to_hash[\"title\"] == sprint)\n end\n\n # If the search returned any milestone with the same title as the current\n # sprint, set the milestone variable to that Milestone object.\n if !existing_sprint.empty?\n milestone = existing_sprint.first.to_hash\n # Otherwise, create a new milestone with the given sprint's name.\n else\n milestone = @gitlab.create_milestone(PROJECT_ID, \"#{sprint}\")\n milestone = milestone.to_hash\n end\n\n # Map between the sprint name and milestone id in GitLab.\n @milestones[\"#{sprint}\"] = milestone[\"id\"]\n end\nend",
"def milestones\n milestone_api = \"spaces/#{params[:id]}/milestones/#{params[:filter]}\" # All Milestones\n space_api = \"spaces/#{params[:id]}\"\n @milestones = ApiTalk::callAPI(milestone_api)\n @space = ApiTalk::Space.getSpaces(space_api)\n end",
"def milestone_list(p_id)\n @milestone_list = Milestone.where(:project_id => p_id)\n end",
"def create_milestones()\n created_milestones = {}\n open_milestones = @client.list_milestones(@@github_project, :state => \"open\")\n closed_milestones = @client.list_milestones(@@github_project, :state => \"closed\")\n\n all_milestones = []\n all_milestones.concat(open_milestones)\n all_milestones.concat(closed_milestones)\n\n # list all github milestones\n all_milestones.each do |milestone|\n created_milestones[milestone.title] = milestone.number\n end\n\n # create new milestones based on JIRA versions\n @doc.xpath(\"//Version[@project='#{@@jira_project}']\").each do |version|\n id = version.xpath(\"@id\").text.to_i\n name = version.xpath(\"@name\").text\n description = version.xpath(\"@description\").text\n\n released = version.xpath(\"@released\")\n released = released ? released.text : \"\"\n released = released == \"true\"\n\n # check if already created\n if created_milestones[name]\n @milestones[id] = created_milestones[name]\n next\n end\n\n puts \"creating milestone #{name}\"\n\n milestone = @client.create_milestone(@@github_project, name, {\n :state => released ? \"closed\" : \"open\",\n :description => description\n })\n\n @milestones[id] = milestone.number\n end\n\n puts \"Milestones:\\n #{@milestones}\\n\\n\"\nend",
"def index\n @milestones = @project.milestones\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @milestones }\n end\n end",
"def get(user_name, repo_name, milestone_id, params={})\n _update_user_repo_params(user_name, repo_name)\n _validate_user_repo_params(user, repo) unless user? && repo?\n _validate_presence_of milestone_id\n normalize! params\n\n get_request(\"/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones/#{milestone_id}\", params)\n end",
"def milestones(w)\n return [] if (!request or !request.project) and (!project)\n str = w.to_s\n year = str[0..3].to_i\n week = str[4..5].to_i\n week_start = Date.commercial(year, week, 1)\n week_end = Date.commercial(year, week, 7)\n rv = []\n r = request\n p = self.project\n \n if r && !p\n r.project.milestones.each { |m|\n date = m.date\n rv << m if date and date >= week_start and date <= week_end\n }\n elsif p\n p.milestones.each { |m|\n date = m.date\n rv << m if date and date >= week_start and date <= week_end\n }\n end\n \n rv\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Get a single milestone = Examples bitbucket = BitBucket.new bitbucket.issues.milestones.get 'username', 'reponame', 'milestoneid'
|
def get(user_name, repo_name, milestone_id, params={})
_update_user_repo_params(user_name, repo_name)
_validate_user_repo_params(user, repo) unless user? && repo?
_validate_presence_of milestone_id
normalize! params
get_request("/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones/#{milestone_id}", params)
end
|
[
"def get(projectId,milestoneId)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"+String(milestoneId)+\"/\"\r\n\t\t\t\tresponse = ZohoHTTPClient.get(url, getQueryMap)\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def get(user_name, repo_name, milestone_id, params={})\n _update_user_repo_params(user_name, repo_name)\n _validate_user_repo_params(user, repo) unless user? && repo?\n _validate_presence_of milestone_id\n normalize! params\n\n get_request(\"/repos/#{user}/#{repo}/milestones/#{milestone_id}\", params)\n end",
"def milestone(repository, number, options = {})\n get \"#{Repository.path repository}/milestones/#{number}\", options\n end",
"def blocks_get_milestone\n milestone = @client.query_get \"blocks/getMilestone\"\n end",
"def get_milestone\n blocks = self.blocks_get_milestone\n if blocks[\"success\"]\n return blocks[\"milestone\"]\n else\n return nil\n end\n end",
"def getMilestone\r\n\t\t\t\t\treturn @milestone\r\n\t\t\t\tend",
"def milestone\n Milestone.find_by_project_id_and_milestone_id(project_id, milestone_id)\n end",
"def fetch()\n puts \"+ Loading github milestones\".blue\n\n @milestones = GitHub.get \"#{REPO}/milestones\", :headers => {\"User-Agent\" => \"Jamoma issues migration\"}\n end",
"def getMilestone(response)\r\n\t\t\t\tmilestones_json = JSON.parse response\r\n\t\t\t\tmilestones_array = milestones_json[\"milestones\"]\r\n\t\t\t\treturn jsonToMilestone(milestones_array[0])\r\n\t\t\tend",
"def getMilestoneId\r\n\t\t\t\t\treturn @milestoneId\r\n\t\t\t\tend",
"def update(projectId,milestone)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"+String(milestone.getId)+\"/\"\r\n\t\t\t\tresponse = ZohoHTTPClient.post(url, getQueryMap, milestone.toParamMAP())\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def create(projectId,milestone)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"\r\n\t\t\t\tresponse = ZohoHTTPClient.post(url, getQueryMap, milestone.toParamMAP())\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def milestones\n Sifter.\n get(api_milestones_url).\n fetch(\"milestones\", []).\n map { |m| Sifter::Milestone.new(m) }\n end",
"def get_milestone_by_number(milestones, n)\n milestones.each do |milestone|\n return milestone if milestone[:number] === n\n end\n return nil\n end",
"def milestones\n @milestones ||= ApiFactory.new 'Issues::Milestones'\n end",
"def milestone_issues(project, milestone, options = {})\n get(\"/projects/#{url_encode project}/milestones/#{milestone}/issues\", query: options)\n end",
"def latest_milestone\n self.milestones.last\n end",
"def milestones(project_id, find = 'all')\n records \"milestone\", \"/projects/#{project_id}/milestones/list\", :find => find\n end",
"def getMilestoneURL\r\n\t\t\t\t\treturn @milestoneUrl\r\n\t\t\t\tend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Create a milestone = Inputs :name Required string = Examples bitbucket = BitBucket.new :user => 'username', :repo => 'reponame' bitbucket.issues.milestones.create :name => 'helloworld'
|
def create(user_name, repo_name, params={})
_update_user_repo_params(user_name, repo_name)
_validate_user_repo_params(user, repo) unless user? && repo?
normalize! params
filter! VALID_MILESTONE_INPUTS, params
assert_required_keys(%w[ name ], params)
post_request("/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones", params)
end
|
[
"def create(projectId,milestone)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"\r\n\t\t\t\tresponse = ZohoHTTPClient.post(url, getQueryMap, milestone.toParamMAP())\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def create_milestones(project_id, milestones)\n Basecamp.records \"milestone\", \"/projects/#{project_id}/milestones/create\", :milestone => milestones\n end",
"def create_milestones(project_id, milestones)\n records \"milestone\", \"/projects/#{project_id}/milestones/create\", :milestone => milestones\n end",
"def create_milestone(project_id, data)\n create_milestones(project_id, [data]).first\n end",
"def create(params)\n $LOG.i \"running \" + __method__.to_s\n @client.post '/hr/v3/fp/milestones', params\n end",
"def create_milestone(project, title, options = {})\n body = { title: title }.merge(options)\n post(\"/projects/#{url_encode project}/milestones\", body: body)\n end",
"def create_milestones()\n created_milestones = {}\n open_milestones = @client.list_milestones(@@github_project, :state => \"open\")\n closed_milestones = @client.list_milestones(@@github_project, :state => \"closed\")\n\n all_milestones = []\n all_milestones.concat(open_milestones)\n all_milestones.concat(closed_milestones)\n\n # list all github milestones\n all_milestones.each do |milestone|\n created_milestones[milestone.title] = milestone.number\n end\n\n # create new milestones based on JIRA versions\n @doc.xpath(\"//Version[@project='#{@@jira_project}']\").each do |version|\n id = version.xpath(\"@id\").text.to_i\n name = version.xpath(\"@name\").text\n description = version.xpath(\"@description\").text\n\n released = version.xpath(\"@released\")\n released = released ? released.text : \"\"\n released = released == \"true\"\n\n # check if already created\n if created_milestones[name]\n @milestones[id] = created_milestones[name]\n next\n end\n\n puts \"creating milestone #{name}\"\n\n milestone = @client.create_milestone(@@github_project, name, {\n :state => released ? \"closed\" : \"open\",\n :description => description\n })\n\n @milestones[id] = milestone.number\n end\n\n puts \"Milestones:\\n #{@milestones}\\n\\n\"\nend",
"def create_milestones(issues)\n # Create a list of issues with unique sprint names.\n uniq_issues = issues.uniq { |issue| issue[:sprint] }\n # Create an array of sprint names.\n sprints = uniq_issues.map { |issue| issue[:sprint] }\n # Remove any empty strings.\n sprints = sprints.reject { |sprint| sprint.nil? || sprint.empty? }\n\n # Iterate through each sprint name in the array.\n sprints.each do |sprint|\n # Search for all existing milestones in the project with the same name as the current sprint.\n existing_milestones = @gitlab.milestones(PROJECT_ID, options: { search: \"#{sprint}\" } )\n\n # Create a list of existing milestones.\n existing_milestones_array = []\n existing_milestones.auto_paginate do |_milestone|\n existing_milestones_array << _milestone.to_hash\n end\n\n # Select any milestone with the same title as the current sprint.\n existing_sprint = existing_milestones_array.select do |_milestone|\n next(_milestone.to_hash[\"title\"] == sprint)\n end\n\n # If the search returned any milestone with the same title as the current\n # sprint, set the milestone variable to that Milestone object.\n if !existing_sprint.empty?\n milestone = existing_sprint.first.to_hash\n # Otherwise, create a new milestone with the given sprint's name.\n else\n milestone = @gitlab.create_milestone(PROJECT_ID, \"#{sprint}\")\n milestone = milestone.to_hash\n end\n\n # Map between the sprint name and milestone id in GitLab.\n @milestones[\"#{sprint}\"] = milestone[\"id\"]\n end\nend",
"def create\n @milestone = @project.milestones.new(milestone_params)\n @milestone.project_id = @project.id\n @milestone.status = \"Created\"\n\n respond_to do |format|\n if @milestone.save\n format.html { redirect_to project_milestones_path(@project), notice: 'Milestone was successfully created.' }\n format.json { render :show, status: :created, location: @milestone }\n else\n format.html { render :new }\n format.json { render json: @milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_group_milestone(id, title, options = {})\n body = { title: title }.merge(options)\n post(\"/groups/#{url_encode id}/milestones\", body: body)\n end",
"def create\n @milestone = @project.milestones.build(milestone_params)\n\n respond_to do |format|\n if @milestone.save\n format.html { redirect_to @project,\n notice: 'Milestone was successfully created.' }\n format.json { render :show, status: :created, location: @milestone }\n else\n format.html { render :new }\n format.json { render json: @milestone.errors,\n status: :unprocessable_entity }\n end\n end\n end",
"def create(project_id, data)\n create_milestones(project_id, [data]).first\n end",
"def create_starting_milestones!\n result = Lighthouse.get_milestones(self.remote_id, self.token.account, self.token.token)\n (result[\"milestones\"] || []).each do |milestone|\n m = self.milestones.create(:name => milestone[\"title\"], :remote_id => milestone[\"id\"], :due_on => milestone[\"due_on\"])\n end\n end",
"def add_milestone\n Milestone.create(\n :project_id => self.project_id, \n :milestone_type => \"Feedback\",\n :description => self.user.username + \" has submitted feedback on \" + self.project.name\n )\n end",
"def add_milestone\n new_completion_status = self.project.completion_status\n latestMilestone = self.project.milestones.find_by(:percentage => new_completion_status[:percentage])\n if latestMilestone == nil\n newMilestone = Milestone.create(\n :project_id => self.project_id, \n :milestone_type => \"Fund\",\n :percentage => new_completion_status[:percentage],\n :description => new_completion_status[:status],\n :fund_id => self.id\n )\n end\n end",
"def create\n params_milestone = params[:milestone]\n\n @milestone = Milestone.new(params[:milestone])\n logger.debug \"Creating new milestone #{@milestone.name}\"\n due_date = nil\n if !params[:milestone][:due_at].nil? && params[:milestone][:due_at].length > 0\n begin\n due_date = DateTime.strptime( params[:milestone][:due_at], current_user.date_format )\n rescue\n due_date = nil\n end\n @milestone.due_at = tz.local_to_utc(due_date.to_time + 1.day - 1.minute) if due_date\n end\n\n @milestone.company_id = current_user.company_id\n\n if @milestone.save\n unless request.xhr?\n flash[:notice] = _('Milestone was successfully created.')\n redirect_to :controller => 'projects', :action => 'edit', :id => @milestone.project\n else\n render :update do |page|\n logger.debug \"Milestone saved, reloading popup with 'parent.refreshMilestones(#{@milestone.project_id}, #{@milestone.id});'\"\n # TODO: this could be replaced with \"page[task_milestone_id].replace :partial => get_milestones\n # except that get_milestone currently returns json, not html\n page << \"parent.refreshMilestones(#{@milestone.project_id}, #{@milestone.id});\"\n end\n end\n Notifications::deliver_milestone_changed(current_user, @milestone, 'created', due_date) rescue nil\n else\n render :action => 'new'\n end\n end",
"def milestones\n @milestones ||= ApiFactory.new 'Issues::Milestones'\n end",
"def update(user_name, repo_name, milestone_id, params={})\n _update_user_repo_params(user_name, repo_name)\n _validate_user_repo_params(user, repo) unless user? && repo?\n _validate_presence_of milestone_id\n\n normalize! params\n filter! VALID_MILESTONE_INPUTS, params\n assert_required_keys(%w[ name ], params)\n\n put_request(\"/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones/#{milestone_id}\", params)\n end",
"def create(project_name, repo_name, description) ; end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Update a milestone = Inputs :name Required string = Examples bitbucket = BitBucket.new bitbucket.issues.milestones.update 'username', 'reponame', 'milestoneid', :name => 'helloworld'
|
def update(user_name, repo_name, milestone_id, params={})
_update_user_repo_params(user_name, repo_name)
_validate_user_repo_params(user, repo) unless user? && repo?
_validate_presence_of milestone_id
normalize! params
filter! VALID_MILESTONE_INPUTS, params
assert_required_keys(%w[ name ], params)
put_request("/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones/#{milestone_id}", params)
end
|
[
"def update(user_name, repo_name, milestone_id, params={})\n _update_user_repo_params(user_name, repo_name)\n _validate_user_repo_params(user, repo) unless user? && repo?\n _validate_presence_of milestone_id\n\n normalize! params\n filter! VALID_MILESTONE_INPUTS, params\n assert_required_keys(%w[ title ], params)\n\n patch_request(\"/repos/#{user}/#{repo}/milestones/#{milestone_id}\", params)\n end",
"def update(projectId,milestone)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"+String(milestone.getId)+\"/\"\r\n\t\t\t\tresponse = ZohoHTTPClient.post(url, getQueryMap, milestone.toParamMAP())\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def edit(milestone_id, params)\n $LOG.i \"running \" + __method__.to_s\n @client.put '/hr/v3/fp/milestones/' + milestone_id, params\n end",
"def update\n @milestone = Milestone.find(params[:id])\n\n respond_to do |format|\n if @milestone.update_attributes(milestone_params)\n format.html { redirect_to @milestone, notice: 'Milestone was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @milestone = Milestone.find(params[:id])\n\n respond_to do |format|\n if @milestone.update_attributes(params[:milestone])\n flash[:notice] = 'Milestone was successfully updated.'\n format.html { redirect_to(@milestone) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @milestone.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @milestone.update(milestone_params)\n format.html { redirect_to @project,\n notice: 'Milestone was successfully updated.' }\n format.json { render :show, status: :ok, location: @milestone }\n else\n format.html { render :edit }\n format.json { render json: @milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @milestone.update(milestone_params)\n format.html { redirect_to @milestone, notice: 'Milestone was successfully updated.' }\n format.json { render :show, status: :ok, location: @milestone }\n else\n format.html { render :edit }\n format.json { render json: @milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @deal_milestone = DealMilestone.find(params[:id])\n\n respond_to do |format|\n if @deal_milestone.update_attributes(params[:deal_milestone])\n format.html { redirect_to @deal_milestone, notice: 'Deal milestone was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @deal_milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_milestone\n\n milestone = params[:milestone_id].blank? ? nil : milestones.find(params[:milestone_id])\n mass_tickets.each do |ticket|\n ticket.milestone = milestone\n ticket.save\n end\n\n mass_update\n\n end",
"def change_milestone(milestone)\n format = milestone&.group_milestone? ? :name : :iid\n body = milestone.nil? ? 'removed milestone' : \"changed milestone to #{milestone.to_reference(project, format: format)}\"\n\n create_note(NoteSummary.new(noteable, project, author, body, action: 'milestone'))\n end",
"def update_milestones\n self.milestones = matching_milestones\n end",
"def update\n respond_to do |format|\n if @cb_milestone.update(cb_milestone_params)\n format.html { redirect_to @cb_milestone, notice: 'Cb milestone was successfully updated.' }\n format.json { render :show, status: :ok, location: @cb_milestone }\n else\n format.html { render :edit }\n format.json { render json: @cb_milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if can? :update, @project_phase_milestone\n respond_to do |format|\n if @project_phase_milestone.update(project_phase_milestone_params)\n format.html { redirect_to \"/projects/#{@project_phase_milestone.project_phase.project.id}/phases/#{@project_phase_milestone.project_phase.id}/milestones/\", notice: \"Milestone was successfully updated.\" }\n format.json { render :show, status: :ok, location: @project_phase_milestone }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @project_phase_milestone.errors, status: :unprocessable_entity }\n end\n end\n else\n respond_to do |format|\n format.html { redirect_to \"/projects/#{@project_phase_milestone.project_phase.project.id}/phases/#{@project_phase_milestone.project_phase.id}/milestones/\", notice: \"You don't have privilege to update a milestone.\" }\n format.json { render :show, status: :ok, location: @project_phase_milestone }\n end\n end\n end",
"def updateStatus(projectId,milestoneId,status)\r\n\t\t\t\turl = getBaseURL+\"projects/\"+String(projectId)+\"/milestones/\"+String(milestoneId)+\"/status/\"\r\n\t\t\t\trequestBody = Hash.new()\r\n\t\t\t\trequestBody[\"status\"] = status\r\n\t\t\t\tresponse = ZohoHTTPClient.post(url, getQueryMap, requestBody)\r\n\t\t\t\treturn $milestonesParser.getMilestone(response)\r\n\t\t\tend",
"def change_name_of_issue(issue_name, name_text)\n\tissue = @client.Issue.find(issue_name)\n\tissue.save({\"fields\"=>{\"summary\"=>name_text}})\nend",
"def update\n @milestone_record = MilestoneRecord.find(params[:id])\n\n respond_to do |format|\n if @milestone_record.update_attributes(params[:milestone_record])\n format.html { redirect_to(@milestone_record, :notice => 'Milestone record was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @milestone_record.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @plan_milestone = PlanMilestone.find(params[:id])\n\n respond_to do |format|\n if @plan_milestone.update_attributes(params[:plan_milestone])\n format.html { redirect_to @plan_milestone, notice: 'Plan milestone was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @plan_milestone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create(user_name, repo_name, params={})\n _update_user_repo_params(user_name, repo_name)\n _validate_user_repo_params(user, repo) unless user? && repo?\n\n normalize! params\n filter! VALID_MILESTONE_INPUTS, params\n assert_required_keys(%w[ name ], params)\n\n post_request(\"/1.0/repositories/#{user}/#{repo.downcase}/issues/milestones\", params)\n end",
"def edit\n @milestone = Milestone.find(params[:id])\n @project = @milestone.project\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /custom_events/1 GET /custom_events/1.xml
|
def show
@custom_event = CustomEvent.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @custom_event }
end
end
|
[
"def calendar_event(event_id)\n record \"/calendar_events/#{event_id}.xml\", :method => :get\n end",
"def get_events\n Resources::Event.parse(request(:get, \"Events\"))\n end",
"def index\n @events = Event.lookup\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @events }\n end\n end",
"def get_events()\n @client.make_request(:get, @client.concat_user_path(\"#{CALL_PATH}/#{id}/events\"))[0]\n end",
"def show\n @simple_event = SimpleEvent.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @simple_event }\n end\n end",
"def new\n @custom_event = CustomEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @custom_event }\n end\n end",
"def parse_events_xml\n h = Hpricot @response.body\n r = h/:response\n r[1..-1]\n end",
"def show\n @event = Event.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @events } \n end\n end",
"def events params = {}, &block\n @connection.request(method: :get, path: build_path(\"/events\", params), response_block: block_given? ? block : default_streamer )\n end",
"def calendar_events(calendar_id)\n records \"/calendars/#{calendar_id}/calendar_events.xml\", :method => :get\n end",
"def get_events(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\tdo_the_get_call( url: api_url, user: @user )\nend",
"def event_info(event_id, event_type = 'sr:match')\n get(\"sports/en/sport_events/#{event_type}:#{event_id}/timeline.xml\")\n end",
"def get_events(args)\n\t\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\t\t\tdo_the_get_call( url: api_url )\n\t\tend",
"def show\n @log_event = LogEvent.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render xml: @log_event }\n end\n end",
"def get_events\n response = request(:get, \"/devmgr/v2/events\")\n #status(response, 200, 'Failed to get current events from server')\n #JSON.parse(response.body)\n response\n end",
"def get_events(args = {})\n begin\n do_get(AppFigures::API::EVENTS, args)\n rescue Exception => e\n puts e.message\n puts e.backtrace\n end\n end",
"def show\n @event_meta = EventMeta.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @event_meta }\n end\n end",
"def show\n @event1 = Event1.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @event1 }\n end\n end",
"def index\n @subevents = Subevent.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @subevents }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /custom_events/new GET /custom_events/new.xml
|
def new
@custom_event = CustomEvent.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @custom_event }
end
end
|
[
"def new\n @event = Event.new_default\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event }\n end\n end",
"def new\n setup_variables\n @event = Event.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event }\n end\n end",
"def new\n @simple_event = Event.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @simple_event }\n end\n end",
"def new\n @event = Event.new \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @events }\n end\n end",
"def new\n @event = Event.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event }\n end\n end",
"def new\n @events_type = EventsType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @events_type }\n end\n end",
"def new_rest\n @page_usage_event = PageUsageEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page_usage_event }\n end\n end",
"def new\n @event = Event.find(params[:event_id])\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @eventtime }\n end\n end",
"def new\n @event_type = EventType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render xml: @event_type }\n end\n end",
"def new\n @event_meta = EventMeta.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event_meta }\n end\n end",
"def create\n @custom_event = CustomEvent.new(params[:custom_event])\n\n respond_to do |format|\n if @custom_event.save\n format.html { redirect_to(@custom_event, :notice => 'Custom event was successfully created.') }\n format.xml { render :xml => @custom_event, :status => :created, :location => @custom_event }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @custom_event.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @event_type = EventType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event_type }\n end\n end",
"def new\n @event1 = Event1.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @event1 }\n end\n end",
"def new\n @calendar_event = CalendarEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @calendar_event }\n end\n end",
"def new\n @project_event = ProjectEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @project_event }\n end\n end",
"def new\n @eventday = Eventday.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @eventday }\n end\n end",
"def new\n @log_event = LogEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render xml: @log_event }\n end\n end",
"def new\n @wedding_event = WeddingEvent.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @wedding_event }\n end\n end",
"def new\n @catalogs_event_type = Catalogs::EventType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @catalogs_event_type }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PUT /custom_events/1 PUT /custom_events/1.xml
|
def update
@custom_event = CustomEvent.find(params[:id])
respond_to do |format|
if @custom_event.update_attributes(params[:custom_event])
logger.info "updated attribute"
flash[:notice] = 'CustomEvent was successfully updated.'
#@custom_events = CustomEvent.find(:all)
#@public_events = CustomEvent.find(:all, :conditions => {:public => true})
#format.html { render :action => "index" }
format.html { redirect_to( :action => 'index') }
format.xml { head :ok }
else
logger.info "failed to update attribute"
format.html { render :action => "edit" }
format.xml { render :xml => @custom_event.errors, :status => :unprocessable_entity }
end
end
end
|
[
"def update\n @custom_event = CustomEvent.find(params[:id])\n\n respond_to do |format|\n if @custom_event.update_attributes(params[:custom_event])\n format.html { redirect_to(@custom_event, :notice => 'Custom event was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @custom_event.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def put_events(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\tputs do_the_put_call( url: api_url, user: @user, json: args[:json] )\nend",
"def update\n #TODO params -> strong_params\n if @event.update(params)\n head :no_content\n else\n render json: @event.errors, status: :unprocessable_entity\n end\n end",
"def create\n @custom_event = CustomEvent.new(params[:custom_event])\n\n respond_to do |format|\n if @custom_event.save\n format.html { redirect_to(@custom_event, :notice => 'Custom event was successfully created.') }\n format.xml { render :xml => @custom_event, :status => :created, :location => @custom_event }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @custom_event.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n event = event.find(params[\"id\"]) \n event.update_attributes(event_params) \n respond_with event, json: event\n end",
"def update\n respond_to do |format|\n if @event.update(event_params)\n format.json { head :no_content }\n else\n format.json { render json: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @event.update(event_params)\n format.html { redirect_to([:admin, @event], notice: 'Event was successfully updated.') }\n format.xml { head :ok }\n website.add_log(user: current_user, action: \"Updated event: #{@event.name}\")\n else\n format.html { render action: \"edit\" }\n format.xml { render xml: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @axis_event.update(axis_event_params)\n format.html { redirect_to @axis_event, notice: 'Axis event was successfully updated.' }\n format.json { render :show, status: :ok, location: @axis_event }\n else\n format.html { render :edit }\n format.json { render json: @axis_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_rest\n @page_usage_event = PageUsageEvent.find(params[:id])\n\n respond_to do |format|\n if @page_usage_event.update_attributes(params[:page_usage_event])\n flash[:notice] = 'PageUsageEvent was successfully updated.'\n format.html { redirect_to(@page_usage_event) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page_usage_event.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @event_meta = EventMeta.find(params[:id])\n\n respond_to do |format|\n if @event_meta.update_attributes(params[:event_meta])\n flash[:notice] = 'EventMeta was successfully updated.'\n format.html { redirect_to(@event_meta) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @event_meta.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def put_event(args)\n\t\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\t\t\tdo_the_put_call( url: api_url, json: args[:json] )\n\t\tend",
"def update\n respond_to do |format|\n if @external_event.update(external_event_params)\n format.html { redirect_to @external_event, notice: 'External event was successfully updated.' }\n format.json { render :show, status: :ok, location: @external_event }\n else\n format.html { render :edit }\n format.json { render json: @external_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @base_event.update(base_event_params)\n format.json { head :no_content }\n else\n format.json { render json: @base_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event_document = EventDocument.find(params[:id])\n\n respond_to do |format|\n if @event_document.update_attributes(params[:event_document])\n @event_document.event.touch\n format.html { redirect_to @event_document, notice: 'Event document was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @event_document.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event = Event.find(params[:id])\n @event.update_attributes(params[:event])\n\n respond_with(:admin, @event)\n end",
"def update\n @create_event = CreateEvent.find(params[:id])\n\n respond_to do |format|\n if @create_event.update_attributes(params[:create_event])\n format.html { redirect_to @create_event, notice: 'Create event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @create_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @simple_event = SimpleEvent.find(params[:id])\n\n respond_to do |format|\n if @simple_event.update_attributes(params[:simple_event])\n format.html { redirect_to @simple_event, notice: 'Simple event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\", :layout => 'dashboard' }\n format.json { render json: @simple_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @custom_event = CustomEvent.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @custom_event }\n end\n end",
"def update\n @event1 = Event1.find(params[:id])\n\n respond_to do |format|\n if @event1.update_attributes(params[:event1])\n format.html { redirect_to(@event1, :notice => 'Event1 was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @event1.errors, :status => :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /custom_events/1 DELETE /custom_events/1.xml
|
def destroy
@custom_event = CustomEvent.find(params[:id])
@custom_event.destroy
respond_to do |format|
format.html { redirect_to(custom_events_url) }
format.xml { head :ok }
end
end
|
[
"def delete_events(args)\n\t\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\t\t\tdo_the_delete_call( url: api_url )\n\t\tend",
"def destroy\n @event.destroy\n\n respond_to do |format|\n format.html { redirect_to(events_path) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event.destroy\n respond_to do |format|\n format.html { redirect_to(admin_events_url) }\n format.xml { head :ok }\n end\n website.add_log(user: current_user, action: \"Deleted event: #{@event.name}\")\n end",
"def destroy\n @event.destroy\n respond_to do | format |\n format.html { redirect_to events_path }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event = Event.find(params[:id])\n @event.destroy\n\n respond_to do |format|\n format.html { redirect_to(admin_events_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event1 = Event1.find(params[:id])\n @event1.destroy\n\n respond_to do |format|\n format.html { redirect_to(event1s_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event = Event.find(params[:id])\n @event.destroy\n\n respond_to do |format|\n format.html { redirect_to(events_url) }\n format.xml { head :ok }\n end\n end",
"def destroy_rest\n @page_usage_event = PageUsageEvent.find(params[:id])\n @page_usage_event.destroy\n\n respond_to do |format|\n format.html { redirect_to(page_usage_events_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @log_event = LogEvent.find(params[:id])\n @log_event.destroy\n\n respond_to do |format|\n format.html { redirect_to(log_events_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event_document = EventDocument.find(params[:id])\n @event_document.event.touch\n @event_document.destroy\n\n respond_to do |format|\n format.html { redirect_to event_documents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @client_event = ClientEvent.find(params[:id])\n @client_event.destroy\n\n respond_to do |format|\n format.html { redirect_to(client_events_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @event_meta = EventMeta.find(params[:id])\n @event_meta.destroy\n\n respond_to do |format|\n format.html { redirect_to(event_metas_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @evento = Evento.find(params[:id])\n @evento.destroy\n\n respond_to do |format|\n format.html { redirect_to(eventos_url) }\n format.xml { head :ok }\n end\n end",
"def delete_event(event)\n @connection.send(Addressable::URI.parse(events_url + \"/#{event.id}\"), :delete)\n end",
"def destroy\n @cim_reg_event = cim_reg_event.find(params[:id])\n @cim_reg_event.destroy\n\n unless @cim_reg_event.errors.empty?\n flash[:notice] = \"WARNING: Couldn't delete cim_reg_event because:\"\n @cim_reg_event.errors.full_messages.each { |m| flash[:notice] << \"<br/>\" << m }\n end\n\n respond_to do |format|\n format.html { redirect_to(events_url) }\n format.xml { head :ok }\n end\n end",
"def delete_event_in_ews(events)\n connection = ExchangeConnection.new(APP_CONFIG[:ews_user_name], APP_CONFIG[:ews_user_password], APP_CONFIG[:ews_endpoint])\n begin\n response_doc = REXML::Document.new(connection.connect(delete_calendar_item_xml(events)))\n status = REXML::XPath.first(response_doc, '//m:DeleteItemResponseMessage').attribute('ResponseClass')\n rescue => e\n @errors << \"Uh-oh, there was an XML exception: #{e}.\"\n return false\n end\n if status.to_s != \"Success\"\n response_code = REXML::XPath.first(response_doc, \"//m:ResponseCode\").text\n message = REXML::XPath.first(response_doc, \"//m:MessageText\").text\n @errors << \"EWS appointment could not be deleted. Status: #{status.to_s}. Response code: #{response_code}. #{message}\"\n return false\n end\n return true\n end",
"def delete_event\r\n event = Event.find_by(id: params[:eventid].to_i)\r\n if event.present?\r\n event.update(status: 3)\r\n lt_update_event_status event, 'archived'\r\n render json: SuccessResponse.new(\r\n code: 200,\r\n message: 'Event Deleted.'\r\n ), adapter: :json, status: :ok\r\n else\r\n render json: ErrorResponse.new(\r\n code: 404,\r\n message: 'Event not found!'\r\n ), adapter: :json, status: :not_found\r\n end\r\n\r\n end",
"def destroy\n @wallevent = Wallevent.find(params[:id])\n @wallevent.destroy\n\n respond_to do |format|\n format.html { redirect_to(wallevents_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n\n\n @upcomingevent = Upcomingevent.find(params[:id])\n @upcomingevent.destroy\n\n respond_to do |format|\n format.html { redirect_to(upcomingevents_url) }\n format.xml { head :ok }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The host name at which to connect to Solr. Default 'localhost'. ==== Returns String:: host name
|
def hostname
unless defined?(@hostname)
@hostname = solr_url.host if solr_url
@hostname ||= user_configuration_from_key('solr', 'hostname')
@hostname ||= default_hostname
end
@hostname
end
|
[
"def hostname\n unless defined?(@hostname)\n @hostname = solr_url.host if solr_url\n @hostname ||= configuration_from_key('solr', @hostname_key)\n @hostname ||= default_hostname\n end\n @hostname\n end",
"def hostname\n name + '.localhost'\n end",
"def hostname\n\t\t\t\t@@hostname ||= if File.exist?('/etc/hostname')\n\t\t\t\t\tIO.read('/etc/hostname').strip\n\t\t\t\telse\n\t\t\t\t\t'localhost'\n\t\t\t\tend\n\t\t\tend",
"def hostname\n unless defined?(@@hostname)\n @@hostname = `hostname`.chomp.strip.downcase\n end\n return @@hostname\n end",
"def host_name\n @host_name\n end",
"def hostname\n @hostname ||= `hostname`.strip\n end",
"def hostname\n @hostname ||= `hostname`.chomp\n end",
"def hostname\n @@hostname\n end",
"def host_name\n `hostname`.chomp\n end",
"def hostname\n return @hostname\n end",
"def hostname\n @hostname ||= ENV['HOSTNAME'] || `hostname`.delete(\"\\n\")\n end",
"def host\n response = ask('What is your Elasticsearch hostname? (Default: localhost) ', String)\n response = 'localhost' if response == ''\n\n response\n end",
"def master_hostname\n @master_hostname ||= (user_configuration_from_key('master_solr', 'hostname') || hostname)\n end",
"def hostname\n @hostname ||= self.name.split('@').last\n end",
"def get_host\n @host\n end",
"def host\n @config.db_hostname\n end",
"def hostname\n FFI::Libvirt.virConnectGetHostname(self)\n end",
"def host\n socket.host\n end",
"def remote_hostname\n Cproton.pn_connection_remote_hostname(@impl)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The port at which to connect to Solr. Defaults to 8981 in test, 8982 in development and 8983 in production. ==== Returns Integer:: port
|
def port
unless defined?(@port)
@port = solr_url.port if solr_url
@port ||= user_configuration_from_key('solr', 'port')
@port ||= default_port
@port = @port.to_i
end
@port
end
|
[
"def port\n @port ||=\n if user_configuration.has_key?('solr')\n user_configuration['solr']['port']\n end || 8983\n end",
"def port\n @port ||= default_port\n end",
"def port\n @port ||= use_ssl ? 636 : 389\n end",
"def port\n server.addr(false)[1]\n end",
"def port\n settings[:port] || PROTOCOLS[settings[:protocol]]\n end",
"def getPort()\n return @uri.port\n end",
"def port\n @connection.port\n end",
"def port\n get_value :port\n end",
"def http_port\n @http_port ||= (ENV[\"PRAX_HTTP_PORT\"] || 20559).to_i\n end",
"def port\n request.port\n end",
"def server_port\n get_header(\"SERVER_PORT\").to_i\n end",
"def port\n @port = @hash.fetch(\"Listen\")\n return @port.to_i\n end",
"def actual_port\n server.actual_port\n end",
"def port\n if @port.to_i == 0\n if self.scheme\n @port = self.class.scheme_mapping[self.scheme.strip.downcase]\n else\n @port = nil\n end\n return @port\n else\n @port = @port.to_i\n return @port\n end\n end",
"def port\n if raw_host_with_port =~ /:(\\d+)$/\n $1.to_i\n else\n standard_port\n end\n end",
"def listening_port\n @dbi.endpoint.port\n end",
"def port\n conf['api']['port'].to_s\n end",
"def local_port\n get('beef.http.port') || '3000'\n end",
"def port\n @hash[\"Listen\"].to_i\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The url path to the Solr servlet (useful if you are running multicore). Default '/solr/default'. ==== Returns String:: path
|
def path
unless defined?(@path)
@path = solr_url.path if solr_url
@path ||= user_configuration_from_key('solr', 'path')
@path ||= default_path
end
@path
end
|
[
"def path\n unless defined?(@path)\n @path = solr_url.path if solr_url\n @path ||= configuration_from_key('solr', @path_key)\n @path ||= default_path\n end\n @path\n end",
"def path\n @path ||=\n if user_configuration.has_key?('solr')\n \"#{user_configuration['solr']['path'] || '/solr'}\"\n end\n end",
"def solr_url\n @solr_url ||= endpoint_url.gsub(/\\/select$/, '')\n end",
"def core_url\n @blacklight_context.default_index.connection.uri.to_s.gsub(%r{^.*\\/solr}, '/solr')\n end",
"def url\n \"http://127.0.0.1:#{port}/solr/\"\n end",
"def url\n \"http://#{host}:#{port}/solr/\"\n end",
"def solr_home\n File.join(configuration.solr_home)\n end",
"def solr_home\n File.join(FileUtils.pwd, 'solr')\n end",
"def solr_base_url\n DatastaxRails::Base.establish_connection unless connection\n port = DatastaxRails::Base.config[:solr][:port]\n path = DatastaxRails::Base.config[:solr][:path]\n protocol = ssl_type ? 'https' : 'http'\n \"#{protocol}://#{current_server}:#{port}#{path}\"\n end",
"def config_path\n File.join( solr_home, 'conf' )\n end",
"def solr_home\n @solr_home ||= configuration_from_key('solr', 'solr_home')\n @solr_home ||= File.join(::Rails.root, 'solr')\n end",
"def config_path\n File.join(solr_home, 'conf')\n end",
"def lib_path\n File.join( solr_home, 'lib' )\n end",
"def lib_path\n File.join( solr_home, 'lib' )\n end",
"def solr_default_configuration_location\n File.join(File.dirname(__FILE__), '../../solr/solr/conf')\n end",
"def solr_default_configuration_location\n File.join( File.dirname(__FILE__), '../../solr/solr/conf' )\n end",
"def solr_base_path=(base_path)\n @solr_home_path, @solr_jetty_path, @solr_data_path = nil,nil,nil\n @solr_base_path = base_path\n end",
"def solr_server\n self.class.solr_server\n end",
"def solr_home_dir\n File.expand_path(File.join(solr_dist_dir, 'example', 'solr'))\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The host name at which to connect to the master Solr instance. Defaults to the 'hostname' configuration option. ==== Returns String:: host name
|
def master_hostname
@master_hostname ||= (user_configuration_from_key('master_solr', 'hostname') || hostname)
end
|
[
"def hostname\n unless defined?(@hostname)\n @hostname = solr_url.host if solr_url\n @hostname ||= configuration_from_key('solr', @hostname_key)\n @hostname ||= default_hostname\n end\n @hostname\n end",
"def hostname\n unless defined?(@hostname)\n @hostname = solr_url.host if solr_url\n @hostname ||= user_configuration_from_key('solr', 'hostname')\n @hostname ||= default_hostname\n end\n @hostname\n end",
"def hostname\n unless defined?(@@hostname)\n @@hostname = `hostname`.chomp.strip.downcase\n end\n return @@hostname\n end",
"def hostname\n @hostname ||= `hostname`.chomp\n end",
"def hostname\n @hostname ||= `hostname`.strip\n end",
"def hostname\n name + '.localhost'\n end",
"def hostname\n @hostname ||= ENV['HOSTNAME'] || `hostname`.delete(\"\\n\")\n end",
"def hostname\n @@hostname\n end",
"def hostname\n return @hostname\n end",
"def hostname\n\t\t\t\t@@hostname ||= if File.exist?('/etc/hostname')\n\t\t\t\t\tIO.read('/etc/hostname').strip\n\t\t\t\telse\n\t\t\t\t\t'localhost'\n\t\t\t\tend\n\t\t\tend",
"def host_name\n @host_name\n end",
"def host_name\n `hostname`.chomp\n end",
"def hostname\n @hostname ||= self.name.split('@').last\n end",
"def hostname\n ssh.exec!(\"hostname\").chomp\n end",
"def master_hostname\n master == \"\" ? \"\" : Relay.find(master).hostname\n end",
"def configured_hostname\n running_config.scan(/hostname\\s*(\\S+)/).flatten.first\n end",
"def hostname\n FFI::Libvirt.virConnectGetHostname(self)\n end",
"def determine_hostname\n @info[:hostname] = @shell.query('HOST', 'hostname')\n end",
"def get_server_domain\n @hostname ||= Socket.gethostname\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The path to the master Solr servlet (useful if you are running multicore). Defaults to the value of the 'path' configuration option. ==== Returns String:: path
|
def master_path
@master_path ||= (user_configuration_from_key('master_solr', 'path') || path)
end
|
[
"def path\n @path ||=\n if user_configuration.has_key?('solr')\n \"#{user_configuration['solr']['path'] || '/solr'}\"\n end\n end",
"def path\n unless defined?(@path)\n @path = solr_url.path if solr_url\n @path ||= configuration_from_key('solr', @path_key)\n @path ||= default_path\n end\n @path\n end",
"def path\n unless defined?(@path)\n @path = solr_url.path if solr_url\n @path ||= user_configuration_from_key('solr', 'path')\n @path ||= default_path\n end\n @path\n end",
"def solr_home\n File.join(configuration.solr_home)\n end",
"def config_path\n File.join( solr_home, 'conf' )\n end",
"def path\n\t\tif self.instance_of?(UNIXServer)\n\t\t\t@path\n\t\telse\n\t\t\t\"\"\n\t\tend\n\tend",
"def config_path\n File.join(solr_home, 'conf')\n end",
"def solr_home\n File.join(FileUtils.pwd, 'solr')\n end",
"def server_path\n \"#{servers_path}/#{@domain}\"\n end",
"def server_root\n return @server_root\n end",
"def solr_home\n @solr_home ||= configuration_from_key('solr', 'solr_home')\n @solr_home ||= File.join(::Rails.root, 'solr')\n end",
"def server_path\n guarded_config_env_value('server_path', 'P_SERVER_PATH')\n end",
"def site_path\n site_path = (TrueClass === site_stage ? SITE_PATH : site_stage || SITE_PATH)\n\n path = relative?(site_path) ? ::File.join(wiki_dir, site_path) : site_path\n path.chomp('/') # ensure no trailing path separator\n path\n end",
"def sitepath\n\t\tunless path\n\t\t\tset_sitepath!\n\t\tend\n\t\tpath.sitepath\n\tend",
"def server_chroot\n\t\troute = Mongrel2::Config::Route.for_request( self ) or\n\t\t\traise Mongrel2::UploadError, \"couldn't find the route config for %s\" % [ self ]\n\t\tserver = route.host.server\n\n\t\tpath = server.chroot\n\t\tpath = '/' if path.empty?\n\n\t\treturn Pathname( path )\n\tend",
"def site_path\n site_dir || settings.site_path\n end",
"def shared_path(path=nil)\n [deploy_path, 'shared', path].compact.join('/')\n end",
"def slave_jar_path\n \"#{@tempdir}/war/WEB-INF/slave.jar\"\n end",
"def solr_default_configuration_location\n File.join(File.dirname(__FILE__), '../../solr/solr/conf')\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
True if there is a master Solr instance configured, otherwise false. ==== Returns Boolean:: bool
|
def has_master?
@has_master = !!user_configuration_from_key('master_solr')
end
|
[
"def is_master_running?\n !list_of_running_instances.select {|a| a.name == \"master\"}.first.nil?\n end",
"def master?\n @server_type == 'master'\n end",
"def master?\n doc = db_command(:ismaster => 1)\n is_master = doc['ismaster']\n ok?(doc) && is_master.kind_of?(Numeric) && is_master.to_i == 1\n end",
"def master?\n @wrapt.master?\n end",
"def currently_master?\n !!@current_wrapper.try(:master?)\n end",
"def registered_master?\n !level_db.get(KEY_PREFIX[:master]).nil?\n end",
"def master?\n return !@slaveof.nil?\n end",
"def master?\n !!@master\n end",
"def master?\n state = get_es_resource(\"/_cluster/state?filter_routing_table=true&filter_metadata=true&filter_indices=true&filter_blocks=true&filter_nodes=true\")\n local = get_es_resource('/_nodes/_local')\n local['nodes'].keys.first == state['master_node']\n end",
"def is_master?\n client = RestClient.where(:api_key =>@api_key).first\n return false if client.nil?\n client.is_master\n end",
"def master?\n !environment.present?\n end",
"def detect_if_master\n read_only = `/usr/pgsql-9.1/bin/pg_controldata /var/lib/pgsql/9.1/data | grep \"Database cluster state\" | awk '{print $NF}'`\n return true if read_only =~ /production/\n end",
"def is_master?\n client = RestClient.where(:api_key => @http_headers[@@header_api_key]).first\n client.is_master\n end",
"def single_mongos?\n ClusterConfig.instance.single_server? && ClusterConfig.instance.mongos?\nend",
"def check_master_connection\n begin\n @master.get_system_state\n rescue\n # some error\n return false\n end\n return true\n end",
"def master_process?\n @workers\n end",
"def target_master_is_localhost?\n is_localhost = false\n is_localhost = true if @target_master.include?(\"localhost\")\n return is_localhost\n end",
"def is_not_master_and_master_is_not_running?\n !master? && !Master.is_master_responding?\n end",
"def set_is_master\n if self.product.has_master?\n self.is_master = false\n else\n self.is_master = true\n end\n true\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The default log_level that should be passed to solr. You can change the individual log_levels in the solr admin interface. If no level is specified in the sunspot configuration file, use a level similar to Rails own logging level. ==== Returns String:: log_level
|
def log_level
@log_level ||= (
user_configuration_from_key('solr', 'log_level') ||
LOG_LEVELS[::Rails.logger.level]
)
end
|
[
"def log_level\n @log_level ||= configuration_from_key('solr', 'log_level')\n @log_level ||= LOG_LEVELS[::Rails.logger.level]\n end",
"def default_log_level\n\t\t\tif $DEBUG\n\t\t\t\tLogger::DEBUG\n\t\t\telsif $VERBOSE\n\t\t\t\tLogger::INFO\n\t\t\telse\n\t\t\t\tLogger::WARN\n\t\t\tend\n\t\tend",
"def log_level\n RAILS_DEFAULT_LOGGER.level\n end",
"def default_log_level(env = ENV)\n\t\t\tif level = env['CONSOLE_LOG_LEVEL']\n\t\t\t\tLEVELS[level] || Logger.warn\n\t\t\telsif $DEBUG\n\t\t\t\tLogger::DEBUG\n\t\t\telsif $VERBOSE.nil?\n\t\t\t\tLogger::WARN\n\t\t\telse\n\t\t\t\tLogger::INFO\n\t\t\tend\n\t\tend",
"def logging_level\n @logging_level\n end",
"def level\n @configuration.default_level\n end",
"def level\n logger.level\n end",
"def log_level\n return unless options[:log_level]\n return @log_level if @log_level\n\n level = options[:log_level].downcase.to_sym\n unless valid_log_level?(level)\n level = :info\n banner \"WARNING - invalid log level specified: \" \\\n \"\\\"#{options[:log_level]}\\\" - reverting to :info log level.\"\n end\n\n @log_level = level\n end",
"def default_log_level(env = ENV)\n\t\t\tif level = (env['CONSOLE_LEVEL'] || env['CONSOLE_LOG_LEVEL'])\n\t\t\t\tLogger::LEVELS[level.to_sym] || Logger.warn\n\t\t\telsif $DEBUG\n\t\t\t\tLogger::DEBUG\n\t\t\telsif $VERBOSE.nil?\n\t\t\t\tLogger::WARN\n\t\t\telse\n\t\t\t\tLogger::INFO\n\t\t\tend\n\t\tend",
"def log_level=(level)\n RAILS_DEFAULT_LOGGER.level = level\n end",
"def log_level\n @log_level ||= :debug\n end",
"def log_level\n @log_level ||= :warn\n end",
"def log_level\n @log_level ||= :debug\n end",
"def log_level\n if ENV[\"RAILS_LOG_LEVEL\"].present?\n ENV[\"RAILS_LOG_LEVEL\"]\n elsif debug_mode\n :debug\n elsif Rails.env.production?\n :error\n elsif Rails.env.development?\n :info\n else\n :fatal\n end\n end",
"def log_level\n (self['resque.log_level'] || 1).to_i\n end",
"def log_level\n %i[DEBUG INFO WARN ERROR FATAL UNKNOWN][logger.level]\n end",
"def get_loglevel\n log_levels = [\"all\", \"garbage\", \"trace\", \"debug\", \"info\", \"warning\", \"error\", \"quiet\"]\n if log_levels.include? @config.log_level\n \" --log-level=#{@config.log_level}\"\n else\n \" --log-level=debug\"\n end\n end",
"def severity()\n @logger.level\n end",
"def log_level\n status == \"failure\" ? :err : (@default_log_level || :notice)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Should the solr index receive a commit after each httprequest. Default true ==== Returns Boolean: auto_commit_after_request?
|
def auto_commit_after_request?
@auto_commit_after_request ||=
user_configuration_from_key('auto_commit_after_request') != false
end
|
[
"def auto_commit_after_request?\n @auto_commit_after_request ||= (configuration_from_key('auto_commit_after_request') != false)\n end",
"def auto_commit?\n\t\t@auto_commit\n\tend",
"def force_solr_commit\n # assuming we're running this after adding\n # some things to Solr, we want to give it a little\n # time to clear the queue. In a test scenario, this\n # should be enough of a wait.\n sleep Pedant::Config.direct_solr_query_sleep_time\n url = \"#{Pedant::Config.search_server}#{Pedant::Config.search_commit_url}\"\n body = ''\n headers = get_search_headers()\n RestClient.send :post, url, body, headers\n end",
"def auto_commit_after_delete_request?\n @auto_commit_after_delete_request ||= (configuration_from_key('auto_commit_after_delete_request') || false)\n end",
"def send_commit\n post_to_solr({},true)\n end",
"def solr_commit\n ActsAsSolr::Post.execute(Solr::Request::Commit.new)\n end",
"def solr_commit\n Solarize::Post.execute(Solr::Request::Commit.new)\n end",
"def commit\n solr_service_connection.commit\n end",
"def auto_commit_after_delete_request?\n @auto_commit_after_delete_request ||=\n (user_configuration_from_key('auto_commit_after_delete_request') || false)\n end",
"def auto_commit(flag=true)\n\t\t@connection.set_auto_commit(flag)\n\tend",
"def solr_save\n Merb.logger.debug \"solr_save: #{self.class.name} : #{record_id(self)}\"\n solr_add to_solr_doc\n solr_commit #if configuration[:auto_commit]\n true\n end",
"def commit\n execute \"commit transaction\"\n @transaction_active = false\n true\n end",
"def commit\n begin\n update_response = @streaming_update_server.commit\n rescue org.apache.solr.common.SolrException => e\n @logger.error(\"SolrException while committing updates\")\n @logger.error(\"#{e.message}\")\n @logger.error(\"#{e.backtrace}\")\n end\n end",
"def reindex(autocommit = true)\n if search_document\n logger.debug(\"Updating #{self.class} #{self.id} in the search indexes.\")\n begin\n solr_server.post solr_xml\n solr_server.commit if autocommit\n rescue \n puts $!\n logger.error(\"Failed to index #{self.class} #{self.id} at #{Time.new}: #{$!}\")\n return false\n end\n end\n end",
"def rebuild_solr_index(commit_after_initial_delete = false)\n\n start_time = Time.now\n \n # Delete everything\n logger.debug 'Deleting every ' + self.to_s\n query_string = '<delete><query>type_t:' + self.to_s + '</query></delete>'\n response = ActsAsSolr::Post.execute(query_string, :update)\n logger.debug response\n \n #By default do not commit the initial delete as this blocks searching\n if commit_after_initial_delete\n solr_commit\n end\n \n #Find the number of documents to be indexed\n n_objects = self.count\n\n iterations = n_objects/BATCH_REINDEX_SIZE\n for i in 0..iterations\n logger.debug \"**********\"\n logger.debug \"INDEXING ITERATION #{i}, INDEXED #{i*BATCH_REINDEX_SIZE}\"\n xml = REXML::Element.new('add')\n self.find(:all, :offset => (i*BATCH_REINDEX_SIZE), :limit => BATCH_REINDEX_SIZE).each do |content|\n xml.add_element content.to_solr_doc\n \n #Uncomment this to see what text is being indexed\n #logger.debug \"Indexing text:#{content.to_solr_doc}\"\n end\n\n # Add the new stuff\n xml = xml.to_s\n logger.debug \"Adding: XML document length = \" + xml.length.to_s\n response = ActsAsSolr::Post.execute(xml, :update)\n logger.debug response\n end\n solr_commit\n solr_optimize\n true\n \n end_time = Time.now\n \n elapsed_time = end_time-start_time\n logger.debug \"INDEXING TIME:#{elapsed_time}\"\n end",
"def autocommit(flag)\n query \"set autocommit=#{flag ? 1 : 0}\"\n self\n end",
"def is_commit()\n @is_commit\n end",
"def after_commit_update_work_index_if_needed\n return unless (\n self.saved_change_to_attribute?(:ohms_xml_text) ||\n self.saved_change_to_attribute?(:searchable_transcript_source)\n )\n return unless work && Kithe::Indexable.auto_callbacks?(work)\n\n work.update_index\n end",
"def after_commit_callback\n callback(:after_commit)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
As for auto_commit_after_request? but only for deletes Default false ==== Returns Boolean: auto_commit_after_delete_request?
|
def auto_commit_after_delete_request?
@auto_commit_after_delete_request ||=
(user_configuration_from_key('auto_commit_after_delete_request') || false)
end
|
[
"def auto_commit_after_delete_request?\n @auto_commit_after_delete_request ||= (configuration_from_key('auto_commit_after_delete_request') || false)\n end",
"def auto_commit_after_request?\n @auto_commit_after_request ||= (configuration_from_key('auto_commit_after_request') != false)\n end",
"def auto_commit_after_request?\n @auto_commit_after_request ||=\n user_configuration_from_key('auto_commit_after_request') != false\n end",
"def marked_for_deletion?\n @deletion\n end",
"def after_delete?\n trigger? && @trigger_name.to_sym == :afterDelete\n end",
"def auto_commit?\n\t\t@auto_commit\n\tend",
"def is_marked_for_delete?\n return @mark_for_delete\n end",
"def delete_statement?\n false\n end",
"def before_delete?\n trigger? && @trigger_name.to_sym == :beforeDelete\n end",
"def before_soft_delete\n return self.soft_deletable?\n end",
"def delete_operation?()\n @delete_op\n end",
"def delete_request?\n @operation == DELETE_REQUEST\n end",
"def is_safe_deleted?\n return !self.deleted_at.nil?\n end",
"def pending_mass_deletion?\n deletion_manager = ResourceDeletionManager.instance\n deletion_manager.currently_deleting_resources? || (!deletion_manager.currently_deleting_resources? && deletion_manager.deletion_failures_occured?)\n end",
"def transactional?\n false\n end",
"def is_commit()\n @is_commit\n end",
"def delete\n if self.class.hooks[:active]\n self.class.hooks[:before_delete].each do |block|\n self.class.hooks[:active] = false\n block.yield self\n self.class.hooks[:active] = true\n end\n end\n\n st = prepare(\"DELETE FROM #{table} WHERE #{pk_clause}\")\n num_deleted = st.execute( *pk_values ).affected_count\n st.finish\n if num_deleted != 1\n false\n else\n if self.class.hooks[:active]\n self.class.hooks[:after_delete].each do |block|\n self.class.hooks[:active] = false\n block.yield self\n self.class.hooks[:active] = true\n end\n end\n true\n end\n end",
"def deleted?\n @deleted == true\n end",
"def delete?\n request_method == :delete\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
The callback to use when automatically indexing records. Defaults to after_save.
|
def auto_index_callback
@auto_index_callback ||=
(user_configuration_from_key('auto_index_callback') || 'after_save')
end
|
[
"def auto_index_callback\n @auto_index_callback ||= (configuration_from_key('auto_index_callback') || 'after_save')\n end",
"def after_update\n super\n self.class.call_es { index_document }\n end",
"def after_update\n super\n self.class.call_es { _index_document }\n end",
"def after_create\n super\n self.class.call_es { _index_document }\n end",
"def after_index(indexable = nil,batch_connection = nil)\n\n end",
"def after_save() end",
"def after_index(*args, &block)\n options = args.last\n if options.is_a?(Hash) && options[:on]\n options[:if] = Array.wrap(options[:if])\n options[:if] << \"self.index_lifecycle == :#{options[:on]}\"\n end\n set_callback(:index, :after, *args, &block)\n end",
"def save!\n if self.changed?\n transaction do\n res = super\n reload\n build_index\n res\n end\n end\n end",
"def save(*args)\n super(*args)\n index\n self\n end",
"def after_set(index)\n # do with data or some notification\n end",
"def add_update_reindex_callback(model, reflection, async:)\n return if model < Elasticsearch::Model\n\n # for why it is needed see reindex_hook.rb\n model.include ActiverecordReindex::ReindexHook\n\n update_callback = callback(async, reflection)\n\n model.after_commit(on: :update) do\n next unless changed_index_relevant_attributes?\n update_callback.call(self)\n end\n end",
"def after_upsert\n end",
"def after_save_hook\n execute_hooks_for(:after, :save)\n end",
"def after_commit_callback\n callback(:after_commit)\n end",
"def fulltextable(&block)\n before_save :update_keywords\n\n self.instance_variable_set(:@index_proc, block)\n end",
"def did_save; end",
"def after_save(object)\n logger.info \"SolrObserver: A #{object.class} was just saved! Updating #{object.metaphors.size} solr documents...\"\n update_solr(object)\n end",
"def activerecord_before_save\n save\n end",
"def solr_save\n solr_index.save\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Logging in rails_root/log as solr_.log as a default. ===== Returns String:: default_log_file_location
|
def default_log_file_location
File.join(::Rails.root, 'log', "solr_" + ::Rails.env + ".log")
end
|
[
"def default_log_file_location\n File.join(::Rails.root, 'log', \"solr_\" + ::Rails.env + \".log\")\n end",
"def log_file\n File.join(FileUtils.pwd, 'log', \"sunspot-solr.log\")\n end",
"def log_file\n File.join(::Rails.root, 'log', \"sunspot-solr-#{::Rails.env}.log\")\n end",
"def default_log_root\n File.join(kitchen_root, Kitchen::DEFAULT_LOG_DIR)\n end",
"def solr_default_configuration_location\n File.join( File.dirname(__FILE__), '../../solr/solr/conf' )\n end",
"def solr_default_configuration_location\n File.join(File.dirname(__FILE__), '../../solr/solr/conf')\n end",
"def log_path\n @options['log_path'] ? File.expand_path(@options['log_path'], @config.root) : default_log_path\n end",
"def log_path\n home_path.join(\"logs\")\n end",
"def default_log_file_name\n @options['log_file_name'] || \"#{@name}.log\"\n end",
"def logfile_path\n distinct_relative_path @config[\"server_log\"]\n end",
"def log_file\n @log_file || Princely::Logging.filename\n end",
"def log_base_dir\n maybe_relative_dir =\n if @log_base_dir ||= log[\"dir\"]\n @log_base_dir\n elsif (global_base_dir = ENV[\"ROBY_BASE_LOG_DIR\"])\n File.join(global_base_dir, app_name)\n else\n \"logs\"\n end\n File.expand_path(maybe_relative_dir, app_dir || Dir.pwd)\n end",
"def log_path\n @log_path || STDOUT\n end",
"def default_file_logger\n logfile = File.expand_path(File.join(\".kitchen\", \"logs\", \"kitchen.log\"))\n Logger.new(:stdout => $stdout, :logdev => logfile, :level => env_log)\n end",
"def log_file\n get_value :logfile\n end",
"def log_directory\n\t\t\tFile.join(working_directory, \"log\")\n\t\tend",
"def log_file_dir()\n @log_file_dir = nil if !defined?(@log_file_dir)\n return @log_file_dir\n end",
"def log_dir\n app.log_dir\n end",
"def pool_logger_location\n ::File.join(logger_location, \"pool.log\")\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Clears both the internal lists of entities and contexts.
|
def clear
@entity_list = {}
@context_list = {}
@last_unique_id = 0
@entity_names = {} # Internal cache of context names for quick key retrieval
end
|
[
"def clear!\n contexts.clear\n attributes.clear\n end",
"def clear!\n context_manager.clear!\n end",
"def clear_context\n end",
"def clear_current\n all_contexts.delete(Thread.current.object_id)\n end",
"def remove_all_contexts\n previous_size = @contexts.size\n @contexts = []\n previous_size\n end",
"def clear_context\n @current_context = nil\n end",
"def clear\n models.each do |model|\n model.store.clear if model.has_store?\n model.identity_map.clear if model.identity_map_on?\n end\n end",
"def clear\n models.each do |model|\n model.adapter.clear\n end\n IdentityMap.clear\n end",
"def clear!\n @context = ContextStack.new\n nil\n end",
"def clear\n reset_random\n @components.clear\n @entities.clear\n @systems.clear\n self\n end",
"def finalize\n @entities.clear\n end",
"def clear()\n @bots.each do |bot|\n bot.group = nil\n bot.remove_all_rooms()\n end\n @bots.clear()\n\n if !@store.nil?\n @store.transaction do\n @store.roots.each do |r|\n @store.delete(r)\n end\n end\n end\n end",
"def clear_changes\n # Clear the top level\n send(:clear_changes_information)\n # Stop if there are no associations configured\n return unless respond_to? :associations\n\n # Clear associations\n associations.keys.each do |attribute|\n [send(attribute)].flatten.each do |entity|\n next unless entity.respond_to? :clear_changes\n\n entity.clear_changes\n end\n end\n # Passback ourself for chaining\n self\n end",
"def clear\n\tself.activations.clear\n\tself.agenda.clear\n\tself.default_facts.clear\n\tself.facts.clear\n\tself.rules.clear\n\tself\n end",
"def reset!\n @context = []\n end",
"def clear()\n @mutex.synchronize {\n each_object &destroy_block\n @idle_list = []\n @active_list = {}\n }\n end",
"def clear\n @extent.clear\n @association.clear if associative?\n end",
"def reset\n identity_map.clear\n plugins.clear\n models.clear\n end",
"def clear()\n @resources.clear\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
++ Creates a new EntityDAO, adding it to the internal list and returning its instance. Entity names should be unique among the same context. (No check is performed about this, though.) They will be converted to strings internally.
|
def new_entity( name, parent_context = nil )
@last_unique_id += 1
entity = V3::EntityDAO.new( @last_unique_id, name.to_s, parent_context )
parent_context.entity_list[ name.to_s ] = entity if parent_context.instance_of?( V3::ContextDAO )
# Cache the key for this new entity:
@entity_names[ get_entity_unique_name(name, parent_context) ] = @last_unique_id
@entity_list[ @last_unique_id ] = entity
end
|
[
"def create_entity\n context.entity = Entity.new(context.to_h)\n context.entity.uuid = UUID.generate(:compact)\n context.entity.display_name ||= context.entity.name\n context.entity.cached_full_name ||= context.entity.decorate.full_name\n context.entity.source ||= :local\n end",
"def get_entity( name, parent_context = nil )\n id = @entity_names[ get_entity_unique_name(name, parent_context) ]\n @entity_list[ id ]\n end",
"def new_entity( name, parent_context = nil )\n @serialized = false\n @factory.new_entity( name, parent_context )\n end",
"def new_entity(entity_class, *args)\n id = @entities.size\n @entities[id] = entity_class.new(id, *args).freeze\n end",
"def add(entity)\n record = dao.new filtered_attributes_for(entity)\n RecordSaver.new(record: record, factory: factory).result\n end",
"def create_entity(name, type, external_id, system_id, content)\n #This is a stub, used for indexing\n end",
"def get_entity( name, parent_context = nil )\n @factory.get_entity( name, parent_context )\n end",
"def new_entity(options, &b)\n @entity_class.new(self, options, &b)\n end",
"def find_or_add_entity(name)\n entity = @entities.find {|e| e.label == name.to_s }\n if entity.nil?\n self.add_entity(name)\n else\n entity\n end\n end",
"def add_entity(entity)\n\t\tif(not @entity_list)\n\t\t\t@entity_list=Array(1, entity)\n\t\telse\n\t\t\t@entity_list.push(entity)\n\t\tend\t\n\tend",
"def entity=newe\n if newe # Propogate the entity's identifying info to the rest of the item\n self.id = newe.id\n self.klass = newe.class\n end\n @entity = newe\n end",
"def create_blank_entity\n\t\treturn Chione::Entity.new( self )\n\tend",
"def entity_factory\n @entity_factory\n end",
"def new_entity(properties = {})\n OData::Entity.with_properties(properties, entity_options)\n end",
"def add_entity entity\n @entities[entity.id] = entity\n entity.engine = self\n @node_lists.each do |sym, node_list|\n node_list.push entity if entity.matches_node? sym\n end\n end",
"def add_entity(entity)\n @entities << entity\n entity.added_to_engine self\n end",
"def get_entity(id)\n \n id_dbs = s_to_dbs(id)\n \n unless @store[id_dbs]\n raise NoEntityError.new id\n end\n \n @created_entities = {}\n build_entity nil, id, id_dbs\n end",
"def new_entity(properties = {})\n FrOData::Entity.with_properties(properties, entity_options)\n end",
"def entity_for_slug\n record = dao.where(slug: slug).first\n factory.create(record) if record\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Creates a new ContextDAO, adding it to the internal list and returning its instance. Context names can be duplicated, to allow multiple childcontexts holding different values of the same group of entities. The suggested way to process the contexts is as a sequential list. (i.e. scanning all the contexts named "result_row" for result values)
|
def new_context( name, parent_context = nil )
@last_unique_id += 1
@context_list[ @last_unique_id ] = V3::ContextDAO.new( @last_unique_id, name.to_s, parent_context )
end
|
[
"def contexts\n @contexts ||= Hash.new\n end",
"def build_context(context: Context.current)\n builder = Builder.new(correlations_for(context).dup)\n yield builder\n context.set_value(CORRELATION_CONTEXT_KEY, builder.entries)\n end",
"def new_context( name, parent_context = nil )\n @serialized = false\n @factory.new_context( name, parent_context )\n end",
"def push_context(context_data)\n if context_data.is_a?(Class)\n context << context_data.new\n else\n context << context_data\n end\n end",
"def context(name = nil, &block)\n name ||= Helpers.generate_uuid\n # context \"created with defaults\" ... 'ContextCreatedWithDefaults'\n class_name = Helpers.to_const_name(name.to_s, PREFIX, SUFFIX)\n if const_defined?(class_name)\n klass = const_get(class_name)\n if ( klass.superclass == self rescue nil )\n warn \"duplicate context definition with the name #{name.inspect} \" +\n \"found at #{caller.first} it is going to be merged with \" +\n \"the previous context definition\"\n else\n raise \"could not create a context with the name #{name.inspect} \" +\n \"as a constant #{class_name} is already defined and is not \" +\n \"another context definition\"\n end\n else\n klass = Class.new(self)\n klass.extend Test::Unit::Context\n klass.context_name = name\n # NOTE: make sure by default we run \"inherited\" setup/teardown hooks\n # unless context code does re-define the hook method e.g. `def setup`\n # instead of using the `setup do` or the setup method marker syntax :\n klass.class_eval do\n def setup; super; end\n def cleanup; super; end\n def teardown; super; end\n end\n const_set(class_name, klass)\n end\n context_definitions << klass\n klass.class_eval(&block)\n klass\n end",
"def create_context_with_separated_entries\n context = create_context_without_separated_entries\n query_class = instance_variable_get :@klass\n if should_query_from_separated_collection? query_class\n new_collection_name = query_class.separated_collection_prefix + separated_value(query_class)\n # self.selector.except!('form_id')\n # filter = context.instance_variable_get(:@view).filter.except('form_id')\n # context.instance_variable_get(:@view).instance_variable_set :@filter, filter\n context.collection.instance_variable_set :@name, new_collection_name\n collection.instance_variable_set :@name, new_collection_name\n end\n instance_variable_set :@context, context\n context\n end",
"def build_row_contexts\n rows = @data.size\n row_contexts = [:default] * rows\n offset = 0\n @contexts.each do |ctx|\n if ctx == :default\n break\n end\n size = ctx[:rows]\n row_contexts[offset...(size + offset)] = [ctx[:id]] * size\n offset += size\n end\n @contexts.reverse_each do |ctx|\n if ctx == :default\n break\n end\n size = ctx[:rows]\n row_contexts[(rows - size)...rows] = [ctx[:id]] * size\n rows -= size\n end\n row_contexts\n end",
"def context_for(context, path)\n return context.dup if !path || path == ''\n new_context = context.dup\n nodes = path.split(/[\\.\\/]/).collect(&:upcase) rescue []\n return new_context.root if nodes.empty?\n level = nodes[0] == '' ? nil : new_context.level\n\n nodes.each_with_index do |node, i|\n case\n when i.zero? && node == '' then new_context.root\n when i.zero? && node == '~' then new_context.set(schema: @user)\n when node == '-' then new_context.up\n when node == '--' then new_context.up.up\n when node =~ /^-+$/ then new_context.up.up.up\n else\n raise Context::InvalidKey if node !~ /^[a-zA-Z0-9_\\$]{,30}$/\n case new_context.level\n when nil\n @meta.find(new_context.traverse(schema: node))\n when :schema\n o = @meta.find_object(new_context.schema, node)\n new_context.traverse(object: node, object_type: o.type)\n when :object\n @meta.find(new_context.traverse(column: node))\n #TODO: Subprograms\n else raise Context::InvalidKey\n end\n end\n end\n new_context\n end",
"def contexts(triple = nil)\n return []\n end",
"def to_a\n @contexts.dup\n end",
"def create_context\n return None.new(self) if empty_and_chainable?\n embedded ? Memory.new(self) : Mongo.new(self)\n end",
"def get_contexts_named( name )\n @factory.get_contexts_named( name )\n end",
"def create_context\n response = client.command(Protocol::Target.create_browser_context).value\n context_id = response['browserContextId']\n\n BrowserContext.new(client: client, id: context_id, browser: self).tap do |context|\n @contexts[context_id] = context\n end\n end",
"def create_execution_context()\n app_ctx = self.application_context\n app_ctx ||= VAPI::Core.create_default_application_context()\n sec_ctx = self.security_context\n sec_ctx ||= VAPI::Core::SecurityContext.new\n return VAPI::Core::ExecutionContext.new(app_ctx, sec_ctx)\n end",
"def parse(json)\n contexts = super(json)\n contexts.collect do |raw_context|\n context = Context.new\n context.id = raw_context[\"id\"]\n context.name = raw_context[\"name\"]\n context.count = raw_context[\"count\"]\n context.count = raw_context[\"icon\"]\n context\n end\n end",
"def context\n ptr = FFI::MemoryPointer::new( Context )\n error = OpenCL.clGetMemObjectInfo(self, CONTEXT, Context.size, ptr, nil)\n error_check(error)\n return Context::new( ptr.read_pointer )\n end",
"def add_context(context)\n\t\t\t@contexts << context\n\t\tend",
"def context\n extract_ids\n apply_builders\n @ctx\n end",
"def result_for( context_name )\n @result.get_contexts_named( context_name )\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
++ Retrieves the unique entity name, used internally to cache its key.
|
def get_entity_unique_name( name, parent_context = nil )
"#{ parent_context ? "#{parent_context.id}-#{parent_context.name}" : '' }-#{ name.to_s }"
end
|
[
"def entity_name\n @entity[:name]\n end",
"def get_entity_unique_name( name, parent_context = nil )\n @factory.get_entity_unique_name( name, parent_context )\n end",
"def object_name_from_external_entity_hash(entity)\n raise \"Not implemented\"\n end",
"def object_name_from_external_entity_hash(entity)\n raise 'Not implemented'\n end",
"def entity_name\n parse\n return @names.first\n end",
"def cached_id_name; end",
"def external_entity_name\n raise \"Not implemented\"\n end",
"def object_name_from_connec_entity_hash(entity)\n raise \"Not implemented\"\n end",
"def js_name(entity)\n if !entity.id\n raise \"No identifier for #{entity.to_json}\"\n end\n entity.id.gsub(/\\W/, '_')\n end",
"def identity_name\n return @identity_name\n end",
"def primary_key_for(entity_name)\n metadata.xpath(\"//EntityType[@Name='#{entity_name}']/Key/PropertyRef\").first.attributes['Name'].value\n end",
"def entity_name\n dataset_key.gsub(/Set$/,'')\n end",
"def name\n @name || object_id.to_s\n end",
"def unique_name\n unique_name = @name\n unique_name += \" (#{@disambiguation})\" if @disambiguation\n return unique_name\n end",
"def entity_id\n @entity[:id]\n end",
"def cache_key\n name.to_s\n end",
"def entityID\n end",
"def get_name_from_id_helper(entity_id, entity_type=nil,list_command_path=nil, subtype=nil)\n return entity_id unless is_numeric_id?(entity_id)\n\n entity_id = entity_id.to_i\n if entity_type.nil?\n entity_type,list_command_path,subtype = self.class.whoami()\n end\n\n match = nil\n response = self.class.get_cached_response(entity_type,list_command_path,subtype)\n if response and response.ok? and response['data']\n match = response['data'].find{|entity|entity_id == entity['id']}\n end\n unless match\n raise DTK::Client::DtkError, \"Not able to resolve entity name, please provide #{entity_type} name.\"\n end\n match['display_name']\n end",
"def to_s\n unique_name.to_s\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Retrieves an entity by its name, given the parent context instance.
|
def get_entity( name, parent_context = nil )
id = @entity_names[ get_entity_unique_name(name, parent_context) ]
@entity_list[ id ]
end
|
[
"def get_entity( name, parent_context = nil )\n @factory.get_entity( name, parent_context )\n end",
"def entity(name)\n @entities[name]\n end",
"def get_entity_unique_name( name, parent_context = nil )\n @factory.get_entity_unique_name( name, parent_context )\n end",
"def get(class_name, id)\n entities[entity_key(class_name, id)]\n end",
"def get_entity(eid)\n endpoint_url = URI.join(self.engine.base_url, \"entities/#{eid}?v=#{self.engine.version}\")\n\n self.get(endpoint_url, {})\n end",
"def get_entity id\n @entities[id]\n end",
"def get_entities_for_context( parent_context = nil )\n @factory.get_entities_for_context( parent_context )\n end",
"def current_entity\n context.current_entity\n end",
"def entity_name\n @entity[:name]\n end",
"def lookup(name, attributes: {})\n entity = entity_by_name(name).dereference\n return nil if entity.invalid?\n return entity.name\n rescue NoMatch\n begin\n create_entity(name, attributes: attributes)\n rescue InvalidRequest => inv\n # caching problem on api side\n raise unless inv.errors.try(:[], 'name') == 'Entity already exists.'\n entity = entity_by_name(name, cachebreaker: Time.now.to_i).dereference\n return entity.name\n end\n return name\n end",
"def parent_entity\n self.class.unscoped.find_by(id: self.parent_id)\n end",
"def get_object(name, parent_id = nil)\n if @objects.key? name then\n @objects[name]\n elsif parent_id.nil? then\n raise Error, \"object #{name} does not exist\"\n else\n add_object name, parent_id\n end\n end",
"def find_or_add_entity(name)\n entity = @entities.find {|e| e.label == name.to_s }\n if entity.nil?\n self.add_entity(name)\n else\n entity\n end\n end",
"def entity\n @entity\n end",
"def find_named_thing(name)\r\n combatant = self.find_combatant(name)\r\n return combatant.associated_model if combatant\r\n self.find_vehicle_by_name(name)\r\n end",
"def get_entity_by_id(id)\n @entities.find { |e| e.id == id }\n end",
"def get(name)\n return @table[name] if @table.has_key?(name)\n return @parent.get(name) unless @parent.nil?\n return nil\n end",
"def find(key)\n entity_class.new Hyperion.find_by_key(key)\n end",
"def get(entity)\n @components[entity.id] \n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
++ Retrieves the contexts named as indicated. (i.e. "all the contexts named 'result_row'")
|
def get_contexts_named( name )
@context_list.values.map{ |context| context if context.name == name }.compact
end
|
[
"def result_for( context_name )\n @result.get_contexts_named( context_name )\n end",
"def get_contexts_named( name )\n @factory.get_contexts_named( name )\n end",
"def contexts\n JSON.parse(raw_contexts())[\"results\"][\"bindings\"].map{|x| x[\"contextID\"][\"value\"] }\n end",
"def context_names\n contexts.map(&:name)\n end",
"def context_for_item(item_name)\n contexts=[]\n items = item(item_name)\n items.each {|item| contexts << item.context}\n return contexts\n end",
"def result_for( context_name )\n @result[ context_name ]\n end",
"def contexts(triple = nil)\n return []\n end",
"def get_contexts(readable = false)\n return Context.all if admin\n\n contexts = self.contexts\n sites.each { |s| s.contexts.each { |c| contexts << c } } if readable\n contexts = contexts.uniq\n contexts\n end",
"def get_all_pertinent_contexts(opts = {})\n return if @already_ran_get_all_pertinent_contexts\n @already_ran_get_all_pertinent_contexts = true\n\n raise(ArgumentError, \"Need a starting context\") if @context.nil?\n\n @contexts = [@context]\n only_contexts = ActiveRecord::Base.parse_asset_string_list(opts[:only_contexts] || params[:only_contexts])\n if @context && @context.is_a?(User)\n # we already know the user can read these courses and groups, so skip\n # the grants_right? check to avoid querying for the various memberships\n # again.\n enrollment_scope = Enrollment\n .shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current)\n .for_user(@context)\n .current\n .active_by_date\n include_groups = !!opts[:include_groups]\n group_ids = nil\n\n courses = []\n if only_contexts.present?\n # find only those courses and groups passed in the only_contexts\n # parameter, but still scoped by user so we know they have rights to\n # view them.\n course_ids = only_contexts.select { |c| c.first == \"Course\" }.map(&:last)\n unless course_ids.empty?\n courses = Course.\n shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).\n joins(enrollments: :enrollment_state).\n merge(enrollment_scope.except(:joins)).\n where(id: course_ids)\n end\n if include_groups\n group_ids = only_contexts.select { |c| c.first == \"Group\" }.map(&:last)\n include_groups = !group_ids.empty?\n end\n else\n courses = Course.\n shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).\n joins(enrollments: :enrollment_state).\n merge(enrollment_scope.except(:joins))\n end\n\n groups = []\n if include_groups\n if group_ids\n Shard.partition_by_shard(group_ids) do |shard_group_ids|\n groups += @context.current_groups.shard(Shard.current).where(:id => shard_group_ids).to_a\n end\n else\n groups = @context.current_groups.shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).to_a\n end\n end\n groups = @context.filter_visible_groups_for_user(groups)\n\n if opts[:favorites_first]\n favorite_course_ids = @context.favorite_context_ids(\"Course\")\n courses = courses.sort_by {|c| [favorite_course_ids.include?(c.id) ? 0 : 1, Canvas::ICU.collation_key(c.name)]}\n end\n\n @contexts.concat courses\n @contexts.concat groups\n end\n\n include_contexts = opts[:include_contexts] || params[:include_contexts]\n if include_contexts\n include_contexts.split(\",\").each do |include_context|\n # don't load it again if we've already got it\n next if @contexts.any? { |c| c.asset_string == include_context }\n context = Context.find_by_asset_string(include_context)\n @contexts << context if context && context.grants_right?(@current_user, session, :read)\n end\n end\n\n @contexts = @contexts.uniq\n Course.require_assignment_groups(@contexts)\n @context_enrollment = @context.membership_for_user(@current_user) if @context.respond_to?(:membership_for_user)\n @context_membership = @context_enrollment\n end",
"def set_matched_context(res)\n if res['outputContexts'].is_a?(Array)\n context = res['outputContexts'].map { |x| x['name'] }\n end\n # Dump the unnecessary projects/newagent-gjetnk/agent/sessions/avatarSessionId/contexts/ stuff\n context.map! { |c| c.split('.').last }\n # Dump anything that isn't the right kind of context, mega, system counters, etc.\n context.reject! { |e| e.include?('projects/newagent-gjetnk/agent/sessions/avatarSessionId/contexts/') }\n context\n end",
"def index\n authorize! :view_contexts, current_account\n @user = current_account\n @contexts = current_account.contexts.order('name')\n respond_with @contexts\n end",
"def getContexts(className)\n taggings = ActsAsTaggableOn::Tagging.where([\"taggable_type like ?\", className]).\n distinct(:context)\n \n contexts = Array.new\n\n # for each context get the set of tags (sorted), and add them to the collection for display on the page\n taggings.each do |tagging|\n contexts << tagging.context\n end\n \n return contexts\n end",
"def build_row_contexts\n rows = @data.size\n row_contexts = [:default] * rows\n offset = 0\n @contexts.each do |ctx|\n if ctx == :default\n break\n end\n size = ctx[:rows]\n row_contexts[offset...(size + offset)] = [ctx[:id]] * size\n offset += size\n end\n @contexts.reverse_each do |ctx|\n if ctx == :default\n break\n end\n size = ctx[:rows]\n row_contexts[(rows - size)...rows] = [ctx[:id]] * size\n rows -= size\n end\n row_contexts\n end",
"def contexts\n @contexts ||= Hash.new\n end",
"def contexts\n @store.contexts\n end",
"def contexts(type_class)\n contexts = ['system/local'] # Always consider the default context\n catalog_resources = catalog.resources.select { |r| r.is_a?(type_class) }\n catalog_resources.each do |res|\n contexts << res[:context]\n end\n contexts.uniq\n end",
"def current_contexts\n if @current_contexts.blank?\n @current_contexts = ( self.section_context.present? ? self.section_context.split(',').map(&:to_sym) : inherited_contexts )\n end\n @current_contexts\n end",
"def context_by_keyword(keyword)\n hash_value(contexts, keyword)\n end",
"def on_context_names(argv, *)\n response = REXML::Element.new('response')\n response.add_attribute('command', 'context_names')\n \n args = {}\n OptionParser.new do |parser|\n parser.on('-i transaction_id', Integer) { |i| args[:i] = i }\n parser.on('-d stack_depth', Integer) { |d| args[:d] = d }\n end.parse(*argv)\n raise OptionParser::MissingArgument unless [:i].all? { |o| args[o] }\n \n response.add_attribute('transaction_id', args[:i])\n DBGP::CONTEXT_NAMES.each_with_index do |name, id|\n context = REXML::Element.new('context')\n context.add_attribute('name', name)\n context.add_attribute('id', id)\n response.add_element(context)\n end\n \n puts response\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
++ Retrieves all the entities for a specific context.
|
def get_entities_for_context( parent_context = nil )
if parent_context.instance_of?( V3::ContextDAO )# Context specified? Return its entity list:
parent_context.entity_list.values
else # Let's do a "manual" search among the entities:
# [Steve, 20150805] This check allows, so far, to have "root entities" laying around,
# waiting to be fetched. 'Still don't know if it's a really useful feature at all...
@entity_list.values.map do |entity|
entity if entity.parent_context == parent_context
end.compact
end
end
|
[
"def get_entities_for_context( parent_context = nil )\n @factory.get_entities_for_context( parent_context )\n end",
"def entities\n @@entities ||= load\n end",
"def entities\n _entities\n end",
"def entities\n @entities ||= []\n end",
"def active_entities\n request :get, '/getActiveEntities'\n end",
"def entities\n return [] unless @manager.respond_to?(:entities)\n @manager.entities.select(&selector).each do |entity|\n yield entity if block_given?\n end\n end",
"def entities\n @entities ||= Entity.from_models(self, @models)\n end",
"def entities\n return map {|entry| entry.entity}\n end",
"def entities_list\n raise 'Not implemented'\n end",
"def living_entities\n getLivingEntities\n end",
"def find_entities\n []\n end",
"def get_all\n Rutodo::Database::Todo.map(&:as_entity)\n end",
"def all\n response = request(:get_all)\n handles = response.values.flatten.collect { |handle| Entity::Handle.build(handle) }\n\n if handles.size == 1\n # Fetch data for single entity\n find(handles.first)\n elsif handles.size > 1\n # Fetch all data for all the entities\n entity_data = get_data_array(handles)\n\n # Build Entity objects and add them to the proxy\n entity_data.each do |data|\n entity = build(data)\n entity.persisted = true\n end\n end\n\n self\n end",
"def fetch_group_entities\n if @entity_group_id.to_i > 0\n @group_entities = EntityGroupDraft.get_group_entity_draft_ids_from_memcache(@entity_group_id)\n else\n fetch_client_published_entities\n end\n end",
"def populate_entities(options = {})\n include_if_offline = options[:include_offline] || false\n i = 0\n while !(entity_pointer = Map.MIDIDeviceGetEntity(@resource, i)).null?\n @entities << Entity.new(entity_pointer, :include_offline => include_if_offline)\n i += 1\n end\n end",
"def populate_entities(options = {})\n include_if_offline = options[:include_offline] || false\n i = 0\n until (entity_pointer = API.MIDIDeviceGetEntity(@resource, i)).null?\n @entities << Entity.new(entity_pointer, include_offline: include_if_offline)\n i += 1\n end\n i\n end",
"def index\n @main_entities = MainEntity.all\n end",
"def get_workspace_entities(workspace_namespace, workspace_name)\n path = self.api_root + \"/api/workspaces/#{uri_encode(workspace_namespace)}/#{uri_encode(workspace_name)}/entities_with_type\"\n process_firecloud_request(:get, path)\n end",
"def find_entities_in_batches(params = {})\n raise \"block required\" unless block_given?\n params[\"page\"] = 1 unless params.key? \"page\"\n params[\"per_page\"] = 50 unless params.key? \"per_page\"\n loop do\n response = @gr_client.entities.get(params)\n yield response[\"entities\"] if response.key? \"entities\"\n break if response.key?(\"meta\") && (response[\"meta\"][\"next_page\"] == false)\n params[\"page\"] += 1\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Retrieves all the (siblings) contexts for a specific context. Note that by specifying +nil+ as a parent context, will result in all root context retrieved.
|
def get_siblings_for_context( parent_context = nil )
@context_list.values.map do |context|
context if context.respond_to?(:parent_context) && (context.parent_context == parent_context)
end.compact
end
|
[
"def get_siblings_for_context( parent_context = nil )\n @factory.get_siblings_for_context( parent_context )\n end",
"def contexts(mode=nil)\n\t\t\tmode ||= :flat\n\n\t\t\tif mode == :flat\n\t\t\t\tqueue, ctxs = @contexts.clone, []\n\t\t\t\twhile (ctx = queue.shift)\n\t\t\t\t\t#\tmyself\n\t\t\t\t\tctxs << ctx\n\t\t\t\t\t#\tall my children\n\t\t\t\t\tqueue += ctx.contexts\n\t\t\t\tend\n\n\t\t\t\tctxs\n\t\t\telse\n\t\t\t\t#\tonly the ones for our immediate children\n\t\t\t\t@contexts\n\t\t\tend\n\t\tend",
"def get_contexts(readable = false)\n return Context.all if admin\n\n contexts = self.contexts\n sites.each { |s| s.contexts.each { |c| contexts << c } } if readable\n contexts = contexts.uniq\n contexts\n end",
"def get_all_pertinent_contexts(opts = {})\n return if @already_ran_get_all_pertinent_contexts\n @already_ran_get_all_pertinent_contexts = true\n\n raise(ArgumentError, \"Need a starting context\") if @context.nil?\n\n @contexts = [@context]\n only_contexts = ActiveRecord::Base.parse_asset_string_list(opts[:only_contexts] || params[:only_contexts])\n if @context && @context.is_a?(User)\n # we already know the user can read these courses and groups, so skip\n # the grants_right? check to avoid querying for the various memberships\n # again.\n enrollment_scope = Enrollment\n .shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current)\n .for_user(@context)\n .current\n .active_by_date\n include_groups = !!opts[:include_groups]\n group_ids = nil\n\n courses = []\n if only_contexts.present?\n # find only those courses and groups passed in the only_contexts\n # parameter, but still scoped by user so we know they have rights to\n # view them.\n course_ids = only_contexts.select { |c| c.first == \"Course\" }.map(&:last)\n unless course_ids.empty?\n courses = Course.\n shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).\n joins(enrollments: :enrollment_state).\n merge(enrollment_scope.except(:joins)).\n where(id: course_ids)\n end\n if include_groups\n group_ids = only_contexts.select { |c| c.first == \"Group\" }.map(&:last)\n include_groups = !group_ids.empty?\n end\n else\n courses = Course.\n shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).\n joins(enrollments: :enrollment_state).\n merge(enrollment_scope.except(:joins))\n end\n\n groups = []\n if include_groups\n if group_ids\n Shard.partition_by_shard(group_ids) do |shard_group_ids|\n groups += @context.current_groups.shard(Shard.current).where(:id => shard_group_ids).to_a\n end\n else\n groups = @context.current_groups.shard(opts[:cross_shard] ? @context.in_region_associated_shards : Shard.current).to_a\n end\n end\n groups = @context.filter_visible_groups_for_user(groups)\n\n if opts[:favorites_first]\n favorite_course_ids = @context.favorite_context_ids(\"Course\")\n courses = courses.sort_by {|c| [favorite_course_ids.include?(c.id) ? 0 : 1, Canvas::ICU.collation_key(c.name)]}\n end\n\n @contexts.concat courses\n @contexts.concat groups\n end\n\n include_contexts = opts[:include_contexts] || params[:include_contexts]\n if include_contexts\n include_contexts.split(\",\").each do |include_context|\n # don't load it again if we've already got it\n next if @contexts.any? { |c| c.asset_string == include_context }\n context = Context.find_by_asset_string(include_context)\n @contexts << context if context && context.grants_right?(@current_user, session, :read)\n end\n end\n\n @contexts = @contexts.uniq\n Course.require_assignment_groups(@contexts)\n @context_enrollment = @context.membership_for_user(@current_user) if @context.respond_to?(:membership_for_user)\n @context_membership = @context_enrollment\n end",
"def contexts\n @contexts ||= Hash.new\n end",
"def get_entities_for_context( parent_context = nil )\n if parent_context.instance_of?( V3::ContextDAO )# Context specified? Return its entity list:\n parent_context.entity_list.values\n else # Let's do a \"manual\" search among the entities:\n # [Steve, 20150805] This check allows, so far, to have \"root entities\" laying around,\n # waiting to be fetched. 'Still don't know if it's a really useful feature at all...\n @entity_list.values.map do |entity|\n entity if entity.parent_context == parent_context\n end.compact\n end\n end",
"def current_contexts\n if @current_contexts.blank?\n @current_contexts = ( self.section_context.present? ? self.section_context.split(',').map(&:to_sym) : inherited_contexts )\n end\n @current_contexts\n end",
"def contexts\n @store.contexts\n end",
"def contexts(triple = nil)\n return []\n end",
"def contexts\n JSON.parse(raw_contexts())[\"results\"][\"bindings\"].map{|x| x[\"contextID\"][\"value\"] }\n end",
"def list_contexts(opts = {})\n data, _status_code, _headers = list_contexts_with_http_info(opts)\n data\n end",
"def contexts\n list = []\n self.each do |task|\n list << task.contexts unless task.contexts == []\n end\n list.flatten.uniq.sort\n end",
"def context_names\n contexts.map(&:name)\n end",
"def get_context_datasets\n all_datasets = DatasetService.get_datasets\n context_datasets_ids = {}\n context_datasets = {}\n\n self.contexts.each do |context|\n context_datasets_ids[context.id] = []\n context.context_datasets.each {|cd| context_datasets_ids[context.id] << cd.dataset_id}\n end\n\n context_datasets_ids.each do |k, v|\n context_datasets[k] =all_datasets.select {|ds| v.include?(ds.id)}\n end\n\n context_datasets\n end",
"def contexts\n if @user.respond_to?(:checken_contexts)\n @user.checken_contexts\n else\n []\n end\n end",
"def get_contexts_named( name )\n @context_list.values.map{ |context| context if context.name == name }.compact\n end",
"def contexts(type_class)\n contexts = ['system/local'] # Always consider the default context\n catalog_resources = catalog.resources.select { |r| r.is_a?(type_class) }\n catalog_resources.each do |res|\n contexts << res[:context]\n end\n contexts.uniq\n end",
"def contexts(triple = nil)\n if triple\n si, pi, oi = triple_to_int(triple)\n value = @spo[si][pi][oi]\n (value && value.keys.map {|ci| int_to_resource(ci)}) || []\n else\n @cspo.keys.map {|ci| int_to_resource(ci)}\n end\n end",
"def context(context_id=nil, dimensions=[])\n all_contexts= context_by_id(context_id)\n\n return all_contexts if dimensions.size==0\n\n contexts=[]\n\n all_contexts=[all_contexts] unless all_contexts.is_a?(Array)\n all_contexts.each do |ctx|\n next unless ctx.has_explicit_dimensions?(dimensions)\n contexts << ctx\n end\n\n return contexts[0] unless context_id.nil?\n contexts\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Internal: For a given +point+ in time, calculates the load which should be handled by transient energy producers, and assigns the calculated values to the producer's load curve. This is the "jumping off point" for calculating the merit order, and note that the method is called once per Merit::POINT. Since Calculator computes a value for every point (default 8,760 of them) even tiny changes can have large effects on the time taken to run the calculation. Therefore, always benchmark / profile your changes! order The Merit::Order being calculated. point The point in time, as an integer. Should be a value between zero and Merit::POINTS 1. producers An object supplying the always_on and transient producers. Returns nothing.
|
def compute_point(order, point, producers)
# Optimisation: This is order-dependent; it requires that always-on
# producers are before the transient producers, otherwise "remaining"
# load will not be correct.
#
# Since this method is called a lot, being able to handle always-on and
# transient producers in separate loops allows us to skip calling
# #always_on? in every iteration. This accounts for a 20% reduction in
# the calculation runtime.
if (remaining = demand(order, point)) < 0
raise SubZeroDemand.new(point, remaining)
end
producers.always_on(point).each do |producer|
remaining -= producer.max_load_at(point)
end
# Ignore the possibility for a Resortable to be delivered as the third
# method argument. We're going to resort the transients anyway.
transients = order.participants.transients(point)
.sort_by { |transient| Convergence.producer_cost(transient, point) }
while producer = transients.shift do
max_load = producer.max_load_at(point)
# Optimisation: Load points default to zero, skipping to the next
# iteration is faster then running the comparison / load_curve#set.
next if max_load.zero?
current = producer.load_curve.get(point)
headroom = max_load - current
chunk = producer.output_capacity_per_unit
remaining = 0 if remaining < 1e-10
next if headroom.zero?
if headroom <= remaining && headroom < chunk
# Strangely the producer has less than one unit of capacity left. We
# assign it to the maximum load.
add_load(producer, point, headroom)
remaining -= headroom
elsif remaining > chunk
# Assign load equal to the size of one plant.
add_load(producer, point, chunk)
remaining -= chunk
# Add the plant back to the collection. Determining the index of the
# first producer which is more expensive -- and inserting before
# that producer -- is 2x faster than resorting the list entirely.
insert_at = transients.index do |other|
Convergence.producer_cost(other, point) >=
Convergence.producer_cost(producer, point)
end
transients.insert(insert_at || transients.length, producer)
else
# There is less total load remaining to be assigned than the
# capacity of a new plant.
add_load(producer, point, remaining) if remaining > 0
assign_price_setting(order, producer, point)
# Optimisation: If all of the demand has been accounted for, there
# is no need to waste time with further iterations and expensive
# calls to Producer#max_load_at.
break
end
end
end
|
[
"def compute_point(order, point, participants)\n if (demand = demand_at(order, point)).negative?\n raise SubZeroDemand.new(point, demand)\n end\n\n demand = compute_always_ons(\n point, demand,\n participants.always_on,\n participants.flex.at_point(point)\n )\n\n dispatchables = participants.dispatchables.at_point(point)\n next_idx = 0\n\n if demand.positive?\n next_idx = compute_dispatchables(point, dispatchables, demand)\n\n # There was unmet demand after running all dispatchables. It is not possible to satisfy any\n # price-sensitive demands (below).\n return if next_idx.nil?\n end\n\n compute_price_sensitives(\n point,\n participants.price_sensitive_users.at_point(point),\n dispatchables,\n next_idx\n )\n\n nil\n end",
"def local_producers(point, price)\n @local.participants.dispatchables.select do |producer|\n (producer.cost_strategy.sortable_cost(point) < price) &&\n (producer.max_load_at(point) > producer.load_curve.get(point))\n end\n end",
"def demand_at(order, point)\n order.demand_calculator.demand_at(point)\n end",
"def rq_prod_point\n return (level + 1) * Params::ROAD_BUILD_COST_BASE\n end",
"def available_capacity(point)\n local_producers(point, @abroad.price_curve.get(point))\n .reduce(0.0) do |sum, prod|\n sum + (prod.max_load_at(point) - prod.load_curve.get(point))\n end\n end",
"def price_at(point, allow_loaded = false) # rubocop:disable Style/OptionalBooleanParameter\n @cost_strategy.price_at(point, allow_loaded)\n end",
"def foreign_producers(point, price)\n @abroad.participants.dispatchables.select do |producer|\n Convergence.producer_cost(producer, point) > price &&\n producer.load_curve.get(point) > 0\n end\n end",
"def load_curve\n @load_curve ||= demand_curve - supply_curve\n end",
"def calculate(order)\n order.participants.lock!\n producers = order.participants.for_calculation\n\n each_point { |point| compute_point(order, point, producers) }\n\n self\n end",
"def participant_at(point)\n return :deficit if deficit?(point)\n\n ps = price_sensitive_at(point)\n\n return ps if ps && ps != @inflex_consumer_marker\n\n # Price-sensitives are always price-setting, except when they are the always-on price-marker,\n # in which case a dispatchable may be price setting if it is more expensive.\n\n di = dispatchable_at(point)\n\n return :surplus if ps.nil? && di.nil?\n\n return di if ps.nil?\n return ps if di.nil?\n\n ps.cost_at(point) > di.cost_at(point) ? ps : di\n end",
"def inflexible_production_marker(order)\n # Can't set a price if there are no dispatchables.\n return nil if @dispatchables.empty?\n\n priced_inflexibles = order.participants.always_on.select(&:provides_price?)\n\n return nil unless priced_inflexibles.any?\n\n loaded_hours = Array.new(Merit::POINTS, false)\n\n Merit::POINTS.times do |point|\n loaded_hours[point] = priced_inflexibles.any? { |inflex| inflex.load_at(point)&.positive? }\n end\n\n MarginalMarker.producer(loaded_hours, @dispatchables)\n end",
"def cost_at(point)\n @cost_strategy.cost_at(point)\n end",
"def preturn_preparations\n # Do not process preturn phase until wait timer finishes\n return if @wait > 0\n \n # Disable the units that have a disabled flag\n @player.units.each{|u|\n if u.disabled\n u.acted = true\n u.disabled = false\n end\n }\n # Play the player's CO theme music\n $game_system.bgm_play(@player.officer.name)\n # Turn off COP and SCOP flags\n @player.officer.cop = false\n @player.officer.scop = false\n # Play sound effect if the player's COP/SCOP is full\n if @player.stored_energy == @player.officer.scop_rate\n Config.play_se(\"superpower\")\n elsif @player.stored_energy >= @player.officer.cop_rate and @player.officer.cop_stars != 0\n Config.play_se(\"power\")\n end\n # If there is a weather effect\n if $game_map.current_weather != 'none'\n # Check if need to turn off the current weather\n if $game_map.turn_weather_off(@player)\n $game_map.set_weather('none')\n end\n end\n # Draw the player's officer tag graphic located at the top of the screen (EDIT the way graphic is drawn)\n $spriteset.draw_officer_tag(@player)\n # Adds funds based on properties owned that give income\n @player.earn_daily_income\n # If the player has any units out or if it's day one (EDIT)\n unless @player.units.size == 0\n @unit_index = 0\n # Skip daily fuel consumption on Day 1\n unless $game_map.day == 1\n @preturn = 2\n else\n @preturn = 3\n end\n else\n @preturn = 5\n end\n end",
"def compute_price\n \n # set the initial state of an order\n self.status = Order.possible_status[:wait_payment]\n \n # use the visitor pattern to traverse the product and its upgrades\n visitor = VisitorPrice.new\n visitor.visit_product product\n upgrades.each do |upgrade|\n visitor.visit_upgrade upgrade\n end\n self.price = visitor.price\n \n end",
"def compute_always_ons(point, demand, always_ons, flex)\n produced = always_ons.sum { |producer| producer.max_load_at(point) }\n\n if produced > demand\n # There is enough production to meet demand and have some left over for flexibles.\n produced -= demand\n\n if produced.positive?\n flex.each do |part|\n produced -= part.barter_at(point, produced, 0)\n break if produced <= 0\n end\n end\n\n demand = 0.0\n elsif produced < demand\n demand -= produced\n end\n\n demand.negative? ? 0.0 : demand\n end",
"def set_par_price\n @game.initial_offering.set_par_price(@company, @par_price)\n @game.market.add_company(@company, @par_price)\n end",
"def calculate_points\n unless self.points\n self.points = PointCalculator.new(self.value, self.promotion).points\n end\n end",
"def price_setting?(point)\n @producer.provides_price? || @producer.load_curve.get(point).zero?\n end",
"def max_load_at(point)\n max_load_curve[point]\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
create a new secondary_publication_number
|
def create
@secondary_publication_number = SecondaryPublicationNumber.new(params[:secondary_publication_number])
@secondary_publication_number.save
end
|
[
"def create\n @primary_publication_number = PrimaryPublicationNumber.new(params[:primary_publication_number])\n @primary_publication_number.save\n end",
"def update\n @secondary_publication_number = SecondaryPublicationNumber.find(params[:id])\n\t@secondary_publication_number.update_attributes(params[:secondary_publication_number])\n end",
"def create\n @primary_publication_number = PrimaryPublicationNumber.new(params[:primary_publication_number])\n\n respond_to do |format|\n if @primary_publication_number.save\n format.html { redirect_to(@primary_publication_number, :notice => 'Primary publication number was successfully created.') }\n format.xml { render :xml => @primary_publication_number, :status => :created, :location => @primary_publication_number }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @primary_publication_number.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @publication_number = PublicationNumber.new(params[:publication_number])\n\n respond_to do |format|\n if @publication_number.save\n format.html { redirect_to(@publication_number, :notice => 'Publication number was successfully created.') }\n format.xml { render :xml => @publication_number, :status => :created, :location => @publication_number }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @publication_number.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def add_number\n return unless %w[techreport manual].include? @bib.type\n\n did = @bib.docidentifier.detect { |i| i.primary == true }\n did ||= @bib.docidentifier.first\n @item.number = did.id if did\n end",
"def update\n @primary_publication_number = PrimaryPublicationNumber.find(params[:id])\n\t @primary_publication_number.update_attributes(params[:primary_publication_number])\n end",
"def create_publication(record, wssr)\n contrib = Contribution.new(\n author_id: author.id,\n cap_profile_id: author.cap_profile_id,\n featured: false, status: 'new', visibility: 'private'\n )\n Publication.create!( # autosaves contrib\n active: true,\n pub_hash: record.pub_hash,\n wos_uid: record.uid,\n pubhash_needs_update: true,\n contributions: [contrib]\n ) do |pub|\n pub.web_of_science_source_record = wssr if wssr.publication.blank?\n end\n end",
"def create_publication(publication)\n post publish_endpoint(\"/publish\"), publication\n end",
"def create_from_linked_urn\n if (params[:urn].blank? || params[:collection].blank?)\n flash[:error] = 'You must specify a URN and a Collection.'\n redirect_to dashboard_url\n return\n end\n \n urnObj = CTS::CTSLib.urnObj(params[:urn].to_s)\n sourceRepo = params[:src]\n sourceCollection = params[:collection]\n \n # get the Parent version URN and publication type\n versionUrn = urnObj.getUrnWithoutPassage()\n \n # if the version Urn is the same as the supplied urn then we don't have a citation specified\n citationUrn = (versionUrn == params[:urn]) ? nil : params[:urn]\n \n pubtype = CTS::CTSLib.versionTypeForUrn(sourceCollection,versionUrn)\n if pubtype.nil?\n flash[:error] = \"No publication found for #{params[:urn]} in #{sourceCollection} inventory.\"\n redirect_to dashboard_url\n return\n end\n \n versionIdentifier = sourceCollection + \"/\" + CTS::CTSLib.pathForUrn(versionUrn,pubtype)\n \n # check to see if the user is already working on the parent publication\n @publication = nil\n existing_identifiers = []\n possible_conflicts = Identifier.find_all_by_name(versionIdentifier, :include => :publication)\n actual_conflicts = possible_conflicts.select {|pc| ((pc.publication) && (pc.publication.owner == @current_user) && !(%w{archived finalized}.include?(pc.publication.status)))}\n existing_identifiers += actual_conflicts\n \n if existing_identifiers.length > 0\n conflicting_publication = existing_identifiers.first.publication\n conflicting_publications = existing_identifiers.collect {|ci| ci.publication}.uniq\n \n if conflicting_publications.length > 1\n flash[:error] = 'Error creating publication: multiple conflicting publications'\n flash[:error] += '<ul>'\n conflicting_publications.each do |conf_pub|\n flash[:error] += \"<li><a href='#{url_for(conf_pub)}'>#{conf_pub.title}</a></li>\"\n end\n flash[:error] += '</ul>'\n redirect_to dashboard_url\n return\n end # end more than one conflicting publication\n \n if (conflicting_publication.status == \"committed\")\n expire_publication_cache\n conflicting_publication.archive\n else\n @publication = conflicting_publication \n end\n end # end test of possible conflicts\n \n if @publication.nil?\n # User doesn't have the parent publication yet so create it\n identifiers_hash = Hash.new\n [versionIdentifier,OACIdentifier.make_name(versionIdentifier)].each do |id|\n key = CTS::CTSLib.getIdentifierKey(id)\n identifiers_hash[key] = Array.new()\n identifiers_hash[key] << id\n end\n @publication = Publication.new()\n @publication.owner = @current_user\n @publication.creator = @current_user\n \n # HACK for IDigGreek to enable link in to create annotations on an edition that doesn't\n # exist in the master repo\n temp_id = nil\n identifier_class = nil\n Sosol::Application.config.site_identifiers.split(\",\").each do |identifier_name|\n ns = identifier_name.constantize::IDENTIFIER_NAMESPACE\n if CTS::CTSLib.getIdentifierKey(versionIdentifier) == ns\n \n identifier_class = Object.const_get(identifier_name)\n temp_id = identifier_class.new(:name => versionIdentifier)\n end\n end\n \n if (@publication.repository.get_file_from_branch(temp_id.to_path, 'master').blank?)\n fullurn = \"urn:cts:#{versionUrn}\"\n # fetch a title without creating from template\n @publication.title = identifier_class.new(:name => identifier_class.next_temporary_identifier(sourceCollection,fullurn,'edition','ed')).name\n @publication.status = \"new\"\n @publication.save!\n \n # branch from master so we aren't just creating an empty branch\n @publication.branch_from_master\n new_cts = identifier_class.new_from_template(@publication,sourceCollection,fullurn,'edition','ed')\n \n # create the inventory metadata records\n # we can't do this until the publication has already been branched from the master \n # because it doesn't exist in the master git repo \n # and is only carried along with the publication until it is finalized\n begin\n # first the inventory record\n CTSInventoryIdentifier.new_from_template(@publication,sourceCollection,versionIdentifier,versionUrn)\n rescue StandardError => e\n @publication.destroy\n flash[:notice] = 'Error creating publication (during creation of inventory excerpt):' + e.to_s\n redirect_to dashboard_url\n return\n end\n \n else\n @publication.populate_identifiers_from_identifiers(\n identifiers_hash,CTS::CTSLib.versionTitleForUrn(sourceCollection,\"urn:cts:#{versionUrn}\"))\n \n if @publication.save!\n @publication.branch_from_master\n \n # create the temporary CTS citation and inventory metadata records\n # we can't do this until the publication has already been branched from the master \n # because they don't exist in the master git repo \n # and are only carried along with the publication until it is finalized\n begin\n # first the inventory record\n CTSInventoryIdentifier.new_from_template(@publication,sourceCollection,versionIdentifier,versionUrn)\n rescue StandardError => e\n @publication.destroy\n flash[:notice] = 'Error creating publication (during creation of inventory excerpt):' + e.to_s\n redirect_to dashboard_url\n return\n end # end creating inventory record\n\n # need to remove repeat against publication model\n e = Event.new\n e.category = \"started editing\"\n e.target = @publication\n e.owner = @current_user\n e.save!\n end # end saving new publication\n end # now we have a publication\n end \n redirect_to(:controller => 'citation_cts_identifiers', \n :action => 'confirm_edit_or_annotate', \n :publication_id => @publication.id,\n :version_id => versionIdentifier,\n :collection => sourceCollection,\n :urn => citationUrn,\n :src => sourceRepo) \n end",
"def add_publication(pub_id)\n add_actions \"AddPublication(#{pub_id})\"\n end",
"def write_number(crl_number)\n crl_number_entry = CrlNumberEntry.where(ca_name: ca_name).first\n crl_number_entry ||= CrlNumberEntry.new(ca_name: ca_name)\n crl_number_entry.number = crl_number\n crl_number_entry.save\n end",
"def secondary_id=(v)\n @secondary_id = alma_string v\n end",
"def new\n @primary_publication_number = PrimaryPublicationNumber.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @primary_publication_number }\n end\n end",
"def create_record(init)\n subject.transaction(requires_new: true) do\n InternalId.create!(\n **scope,\n usage: usage_value,\n last_value: init.call(subject) || 0\n )\n end\n rescue ActiveRecord::RecordNotUnique\n lookup\n end",
"def create_new_major_version(created_by_id = nil)\n #get most recent version number\n new_maj_ver = self.survey_versions.maximum(:major).to_i + 1\n\n #create new version\n new_sv = self.survey_versions.build(:major=>new_maj_ver, :minor=>0)\n new_sv.published = false\n new_sv.locked = false\n new_sv.archived = false\n new_sv.created_by_id = created_by_id || self.created_by_id\n new_sv.pages.build :page_number => 1, :survey_version => new_sv\n new_sv.tap {|sv| sv.save!}\n end",
"def create\n get_form_data\n publication = params[:publication]\n publication[:publication_type_id] = 1\n @publication = Publication.new(publication)\n\n respond_to do |format|\n if @publication.save\n expire_action :action => :index\n \n flash[:notice] = 'Publications was successfully created.'\n format.html { redirect_to publication_url(@publication) }\n format.xml { render :xml => @publication, :status => :created, :location => @publication }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @publication.errors.to_xml }\n end\n end\n end",
"def create_node\n unless create_node = pubsub.find_first('ns:create', :ns => self.class.registered_ns)\n self.pubsub << (create_node = XMPPNode.new('create', self.document))\n create_node.namespace = self.pubsub.namespace\n end\n create_node\n end",
"def create_distribution_agreement_document\n \n return if @distribution_agreement.documents\n \n template = Document.where(uuid: \"38e2814a-45ce-11e5-b8b5-d43d7eecec4d\")\n .first_or_create(\n title: \"Self Distribution\",\n document_type: \"Template\",\n body: \"You represent and warrant that you are free to enter into and abide by the \\r\\nterms of this Agreement and that you are the sole owner of the master recordings embodying the following compositions\",\n text_content: \"DISTRIBUTION AGREEMENT\",\n tag: \"Distribution\",\n uuid: \"38e2814a-45ce-11e5-b8b5-d43d7eecec4d\",\n )\n\n doc = CopyMachine.copy_document( template )\n\n doc.update( \n :belongs_to_id => @distribution_agreement.id,\n :belongs_to_type => @distribution_agreement.class.name,\n :account_id => @account.id,\n :template_id => template.id,\n title: @distribution_agreement.title.gsub('COPY', ''),\n expires: false\n )\n set_document_user( CopyMachine.create_document_users( template, doc ) , 'DISTRIBUTOR')\n\n \n end",
"def set_NewSerialNumber(value)\n set_input(\"NewSerialNumber\", value)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
update an existing secondary_publication_number
|
def update
@secondary_publication_number = SecondaryPublicationNumber.find(params[:id])
@secondary_publication_number.update_attributes(params[:secondary_publication_number])
end
|
[
"def update\n @primary_publication_number = PrimaryPublicationNumber.find(params[:id])\n\t @primary_publication_number.update_attributes(params[:primary_publication_number])\n end",
"def update\n @primary_publication_number = PrimaryPublicationNumber.find(params[:id])\n\n respond_to do |format|\n if @primary_publication_number.update_attributes(params[:primary_publication_number])\n format.html { redirect_to(@primary_publication_number, :notice => 'Primary publication number was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @primary_publication_number.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @secondary_publication_number = SecondaryPublicationNumber.new(params[:secondary_publication_number])\n\t@secondary_publication_number.save\n end",
"def update\n @publication_number = PublicationNumber.find(params[:id])\n\n respond_to do |format|\n if @publication_number.update_attributes(params[:publication_number])\n format.html { redirect_to(@publication_number, :notice => 'Publication number was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @publication_number.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @primary_publication = PrimaryPublication.find(params[:id])\n\t @study = Study.find(@primary_publication.study_id)\t\n \n # Handle Primary Publication Identifier list management -------------------------------------------\n id_numbers = params[:publication_ids]\n id_types = params[:publication_types]\n\n current_values = PrimaryPublicationNumber.where(:primary_publication_id=>@primary_publication.id)\n current_values_by_id = Hash.new\n current_values.each do |cv|\n current_values_by_id[cv.id] = cv\n end\n unless id_numbers.nil?\n # for each of the identifiers specified\n id_numbers.keys.each do |key|\n this_number = id_numbers[key]\n this_type = id_types[key]\n # if the key is negative, it means we need to create a new entry in the database\n if key.to_i < 0\n PrimaryPublicationNumber.create(:primary_publication_id=>@primary_publication.id, :number=>this_number, :number_type=>this_type)\n else\n # if the key is positive, collect the pre-existing identifier and update it with the new information\n ppid = PrimaryPublicationNumber.find(key)\n ppid.number = this_number\n ppid.number_type = this_type\n ppid.save\n\n # remove this from the current_values hash so we know we're still using it\n current_values_by_id.delete(ppid.id)\n end\n end\n end\n\n # get rid of any primary publication numbers that were not included this time\n current_values_by_id.keys.each do |k|\n PrimaryPublicationNumber.destroy(k)\n end\n \n # Now refresh list of publication identifiers\n @publication_ids = PrimaryPublicationNumber.find(:all, :conditions=>[\"primary_publication_id = ?\", @primary_publication.id])\n \n if @saved = @primary_publication.update_attributes(params[:primary_publication])\n @message_div = \"saved_indicator_1\"\n @new_citation = @study.get_citation.gsub(\"\\n\",\"\")\n @author = \"#{@study.get_first_author} (#{@primary_publication.pmid})\"\n else\n problem_html = create_error_message_html(@primary_publication.errors)\n flash[:modal_error] = problem_html\n @error_partial = \"layouts/info_messages\" \n @error_div = \"validation_message\" \n end\n # Return to previous page\n # redirect_to :back\n end",
"def update_study_site_num(new_num)\n ses_site_number.set new_num\n save_ses.click\n end",
"def save_postal_desc_number\n @student = Student.find(params[:student][:id])\n @student.update_attribute(:postal_desc_number, params[:student][:postal_desc_number])\n end",
"def edit\n @secondary_publication = SecondaryPublication.find(params[:id])\n\t@secondary_publication_numbers = SecondaryPublicationNumber.where(:secondary_publication_id => @secondary_publication.id).all\n @extraction_form_id = @secondary_publication.extraction_form_id\n\t@study_id = @secondary_publication.study_id\n\t@editing = true\nend",
"def update_references(new_publication) ; end",
"def update\n pub_id[:identifier_value] = value\n pub_id[:identifier_uri] = uri\n pub_id\n end",
"def set_secondary_id\n self.update_attribute :cp_secondary_id, self.id\n end",
"def create\n @primary_publication_number = PrimaryPublicationNumber.new(params[:primary_publication_number])\n @primary_publication_number.save\n end",
"def save_desc_number\n @student = Student.find(params[:student][:id])\n @student.update_attribute(:desc_number, params[:student][:desc_number])\n end",
"def write_number(crl_number)\n @db.execute('UPDATE crl_number SET number=?', crl_number)\n end",
"def update_person_number\n discipline = Discipline[event.discipline]\n default_number_issuer = NumberIssuer.find_by_name(RacingAssociation.current.short_name)\n if person && event.number_issuer && event.number_issuer != default_number_issuer && number.present? && !RaceNumber.rental?(number, discipline)\n person.updater = updater\n person.add_number(number, discipline, event.number_issuer, event.date.year)\n end\n end",
"def shift_display_numbers(study_id)\n myNum = self.display_number\n hi_pubs = SecondaryPublication.find(:all, :conditions => [\"study_id = ? AND display_number > ?\", study_id, myNum])\n hi_pubs.each { |pub|\n tmpNum = pub.display_number\n pub.display_number = tmpNum - 1\n pub.save\n }\n end",
"def update(publication, options = {})\n body = options.has_key?(:body) ? options[:body] : {}\n body[:publication] = publication\n\n response = @client.put \"/api/topics/#{@topic_id}/publications/#{@id}\", body, options\n\n return response\n end",
"def secondary_id=(v)\n @secondary_id = alma_string v\n end",
"def update\n @student_publication = StudentPublication.find(params[:id])\n\n respond_to do |format|\n if @student_publication.update_attributes(params[:student_publication])\n format.html { redirect_to(@student_publication, :notice => 'Student publication was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @student_publication.errors, :status => :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
destroy the secondary_publication_number with id = params[:id]
|
def destroy
thisNumber = SecondaryPublicationNumber.find(params[:id])
thisNumber.destroy
@secondary_publications = @study.get_secondary_publications(params[:extraction_form_id])
end
|
[
"def destroy\n @primary_publication_number = PrimaryPublicationNumber.find(params[:id])\n @primary_publication_number.destroy\n\n respond_to do |format|\n format.html { redirect_to(primary_publication_numbers_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @publication_number = PublicationNumber.find(params[:id])\n @publication_number.destroy\n\n respond_to do |format|\n format.html { redirect_to(publication_numbers_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n \tputs (\"CALL TO DESTROY -------------\")\n @secondary_publication = SecondaryPublication.find(params[:id])\n\t@study_id = @secondary_publication.study_id\n\t@study = Study.find(@study_id)\n\t@project = Project.find(@study.project_id)\t\n\t@secondary_publication.shift_display_numbers(@study_id)\n\t@extraction_form_id = @secondary_publication.extraction_form_id\n @secondary_publication.destroy\n secondary_publications = []\n @secondary_publications = SecondaryPublication.find(:all, :order => 'display_number ASC', :conditions => {:study_id => @study_id, :extraction_form_id=>@extraction_form_id})\n @secondary_publication = SecondaryPublication.new\n puts \"Secondary Publications is of length #{@secondary_publications.length}\\n\\n\"\n end",
"def destroy\n\n @publication = Publication.find_by_id(params[:id])\n @publication.destroy\n flash[:success] = \"Journal publication deleted.\"\n redirect_to :action=>\"index\"\n end",
"def destroy\n @primary_publication = PrimaryPublication.find(params[:id])\n @primary_publication.destroy\n\n respond_to do |format|\n format.html { redirect_to(primary_publications_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @publication = Publication.find(params[:id])\n @publication.destroy\n\n respond_to do |format|\n format.html { redirect_to(publications_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @student_publication = StudentPublication.find(params[:id])\n @student_publication.destroy\n\n respond_to do |format|\n format.html { redirect_to(student_publications_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @publication = Publication.find(params[:id])\n @publication.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_publications_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @sp_bsb_publication = SpBsbPublication.find(params[:id])\n @sp_bsb_publication.destroy\n\n respond_to do |format|\n format.html { redirect_to sp_bsb_publications_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @primary = Primary.find(params[:id])\n @primary.destroy\n\n respond_to do |format|\n format.html { redirect_to(primaries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @publication = Oktopartial::Publication.find(params[:id])\n @publication.destroy\n\n respond_to do |format|\n format.html { redirect_to(:action => :index) }\n format.xml { head :ok }\n end\n end",
"def destroy\n #@publication_type = PublicationType.find(params[:id])\n @publication_type.destroy\n\n respond_to do |format|\n format.html { redirect_to publication_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n Ccspublication.find(params[:id]).destroy\n flash[:success] = \"ross-Cultural Studies Publication destroyed.\"\n redirect_to ccspublications_url\n end",
"def destroy\n @publication_type = PublicationType.find(params[:id])\n @publication_type.destroy\n\n respond_to do |format|\n format.html { redirect_to publication_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n\t\t@publication.destroy\n\n\t\trespond_to do |format|\n\t\t\tformat.html { redirect_to(publications_url) }\n\t\t\tformat.xml { head :ok }\n\t\tend\n\tend",
"def destroy\n @basic_publication.destroy\n respond_to do |format|\n format.html { redirect_to basic_publications_url, notice: 'Publicação deletada com sucesso.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @publink = Publink.find(params[:id])\n @publink.destroy\n\n respond_to do |format|\n format.html { redirect_to publinks_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @saved_publication.destroy\n respond_to do |format|\n format.html { redirect_to saved_publications_url, notice: 'Saved publication was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @publication.destroy\n respond_to do |format|\n format.html { redirect_to publications_url }\n format.json { head :no_content }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /product_cates GET /product_cates.json
|
def index
@product_cates = ProductCate.all
end
|
[
"def index\n @product_cates = ProductCate.page(params[:page]).order(\"updated_at DESC\")\n end",
"def index\n @crates = Crate.all\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 @product_categories = ProductCategory.all\n\n render json: @product_categories\n end",
"def index\n @conductors = Conductor.all\n render :json => @conductors\n end",
"def index\n @candies_products = CandiesProduct.all\n end",
"def index\n @care_plans = CarePlan.all\n render json: @care_plans\n end",
"def index\n @coupon_products = CouponProduct.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @coupon_products }\n end\n end",
"def index\n @cn_curves = CnCurve.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @cn_curves }\n end\n end",
"def list\n hash = JSON.parse(CrateAPI::Base.call(\"#{CrateAPI::Base::CRATES_URL}/#{CRATE_ACTIONS[:list]}\", :get))\n return Crates.from_array(hash[\"crates\"])\n end",
"def index\n @product_cats = ProductCat.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @product_cats }\n end\n end",
"def index\n @customers = Customer.all\n\n render json: @customers\n end",
"def index\n @discharges = Discharge.all\n render json: @discharges\n end",
"def currencys\n path = '/v1/common/currencys'\n request_method = 'GET'\n params = {}\n perform(path, params, request_method)\n end",
"def index\n @coupons = Coupon.where('shop_id = ?', params[:shop_id])\n\n respond_to do |format|\n format.html { show_from_resource('index', 'shop_index') }\n format.json { render json: @coupons }\n end\n end",
"def index\n @citations = Citation.all\n\n render json: @citations\n end",
"def customers\n ShopifyAPI::Customer.all\n end",
"def show\n @contract_consumption = ContractConsumption.find(params[:id])\n @contract_product = @contract_consumption.contract_product\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @contract_consumption }\n end\n end",
"def index\n @charges = Charge.all\n\n render json: @charges\n end",
"def currencies\n @client.make_request :get, settings_path('currencies')\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /product_cates POST /product_cates.json
|
def create
@product_cate = ProductCate.new(product_cate_params)
respond_to do |format|
if @product_cate.save
format.html { redirect_to @product_cate, notice: 'Product cate was successfully created.' }
format.json { render :show, status: :created, location: @product_cate }
else
format.html { render :new }
format.json { render json: @product_cate.errors, status: :unprocessable_entity }
end
end
end
|
[
"def index\n @product_cates = ProductCate.all\n end",
"def create\n @candies_product = CandiesProduct.new(candies_product_params)\n\n respond_to do |format|\n if @candies_product.save\n format.html { redirect_to @candies_product, notice: 'Candies product was successfully created.' }\n format.json { render :show, status: :created, location: @candies_product }\n else\n format.html { render :new }\n format.json { render json: @candies_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @copon = Copon.new(copon_params)\n get_product(@copon, params.require(:copon)[:product])\n set_associative_criteria @copon, params.require(:copon)\n\n respond_to do |format|\n if @copon.save\n format.html { redirect_to @copon, notice: 'Copon was successfully created.' }\n format.json { render :show, status: :created, location: @copon }\n else\n format.html { render :new }\n format.json { render json: @copon.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @customer_event_product = CustomerEventProduct.new(customer_event_product_params)\n\n respond_to do |format|\n if @customer_event_product.save\n format.html { redirect_to :back, notice: 'Product was successfully added.', method: :get }\n format.js\n else\n format.html { render :new }\n format.json { render json: @customer_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\n @prd_attribute = PrdAttribute.new\n\n @prd_attribute.bill_type_id = params[:prd_attribute]['bill_type'].to_i\n @prd_attribute.name = params[:prd_attribute]['name']\n @prd_attribute.rollover = params[:prd_attribute]['rollover']\n @prd_attribute.code = params[:prd_attribute]['code']\n @prd_attribute.prd_type = params[:prd_attribute]['prd_type']\n @prd_attribute.description = params[:prd_attribute]['description']\n @prd_attribute.status_id = params[:prd_attribute]['status'].to_i\n\n @prd_attribute.service_type_id = params[:prd_attribute]['service_type'].to_i\n @prd_attribute.monthly_fee = params[:prd_attribute]['monthly_fee'].to_i\n @prd_attribute.subscription_fee = params[:prd_attribute]['subscription_fee'].to_i\n @prd_attribute.target_user = params[:prd_attribute]['target_user']\n @prd_attribute.start_date = params[:prd_attribute]['start_date']\n @prd_attribute.end_date = params[:prd_attribute]['end_date']\n\n respond_to do |format|\n if @prd_attribute.save\n format.html { redirect_to(@prd_attribute, :notice => 'PrdAttribute was successfully created.') }\n format.xml { render :xml => @prd_attribute, :status => :created, :location => @prd_attribute }\n format.json {\n\t\t\tproduct = Product.new\n product.prd_attribute_id = @prd_attribute.id\n product.save!\n\n # bundle일 때에는 해당하는 product id들을 저장\n #\n if params[:prd_attribute]['prd_type'].upcase == 'BUNDLE'\n product_ids = []\n\t\t\t params[:prd_attribute]['ref_products'].each do |product_id|\n\t\t\t product_ids << product_id['product_id'].to_s\n\t\t end\n\t\t @prd_attribute.ref_products = product_ids.join(\",\")\n end \n\t\t @prd_attribute.save\n\n # product devices 저장\n #\n if not params[:prd_attribute]['devices'].blank?\n params[:prd_attribute]['devices'].each do |device|\n prd_attribute_device = PrdAttributeDevice.new\n prd_attribute_device.code_factor_id = device['device'].to_i\n prd_attribute_device.prd_attribute_id = @prd_attribute.id\n prd_attribute_device.product_id = product.id\n prd_attribute_device.save!\n end\n end\n\n # product에 대한 기본 conditions 설정\n #\n product.set_default_conditions(@prd_attribute, product)\n\n\t\t\trender :json => mapping_to_hash(@prd_attribute, PrdAttribute.json_mapping_table), :status => :created, :location => @prd_attribute \n\t\t}\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @prd_attribute.errors, :status => :unprocessable_entity }\n format.json { \n\t\t\trender :json => @prd_attribute.errors, :status => :unprocessable_entity \t}\n end\n end\n end",
"def create\n @discounted_product = DiscountedProduct.new(discounted_product_params)\n\n respond_to do |format|\n if @discounted_product.save\n format.html { redirect_to @discounted_product, notice: 'Discounted product was successfully created.' }\n format.json { render :show, status: :created, location: @discounted_product }\n else\n format.html { render :new }\n format.json { render json: @discounted_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @discount = Discount.new(params[:discount])\n\n if @discount.save\n render json: @discount, status: :created, location: @discount\n else\n render json: @discount.errors, status: :unprocessable_entity\n end\n end",
"def create\n @client_product = ClientProduct.new(client_product_params)\n @client_product.client = @client\n @client_product.creator = current_user\n respond_to do |format|\n if @client_product.save\n format.html { redirect_to @client, notice: 'Custom price was successfully created.' }\n format.json { render :show, status: :created, location: @client_product }\n else\n format.html { render :new }\n format.json { render json: @client_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @cryo_product = CryoProduct.new(cryo_product_params)\n\n respond_to do |format|\n if @cryo_product.save\n format.html { redirect_to @cryo_product, notice: 'Cryo product was successfully created.' }\n format.json { render :show, status: :created, location: @cryo_product }\n else\n format.html { render :new }\n format.json { render json: @cryo_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @discounts_product = DiscountsProduct.new(discounts_product_params)\n\n respond_to do |format|\n if @discounts_product.save\n format.html { redirect_to @discounts_product, notice: 'Discounts product was successfully created.' }\n format.json { render :show, status: :created, location: @discounts_product }\n else\n format.html { render :new }\n format.json { render json: @discounts_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @characteristics_product = CharacteristicsProduct.new(characteristics_product_params)\n\n respond_to do |format|\n if @characteristics_product.save\n format.html { redirect_to @characteristics_product, notice: \"Characteristics product was successfully created.\" }\n format.json { render :show, status: :created, location: @characteristics_product }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @characteristics_product.errors, status: :unprocessable_entity }\n end\n end\n 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 @template_cate = Templates::Cate.new(template_cate_params)\n\n respond_to do |format|\n if @template_cate.save\n format.html { redirect_to @template_cate, notice: 'Cate was successfully created.' }\n format.json { render action: 'show', status: :created, location: @template_cate }\n else\n format.html { render action: 'new' }\n format.json { render json: @template_cate.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @product_cost = ProductCost.new(params[:product_cost])\n\t@products = Product.find_all\n\t@tax_masters = TaxMaster.find_all\n\n respond_to do |format|\n if @product_cost.save\n format.html { redirect_to @product_cost, :notice => 'Product cost was successfully created.' }\n format.json { render :json => @product_cost, :status => :created, :location => @product_cost }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @product_cost.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @coupon_product = CouponProduct.new(params[:coupon_product])\n\n respond_to do |format|\n if @coupon_product.save\n format.html { redirect_to @coupon_product, notice: 'Coupon product was successfully created.' }\n format.json { render json: @coupon_product, status: :created, location: @coupon_product }\n else\n format.html { render action: \"new\" }\n format.json { render json: @coupon_product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @customer_price = CustomerPrice.new(params[:customer_price])\n\n respond_to do |format|\n if @customer_price.save\n format.html { redirect_to @customer_price, notice: 'Customer price was successfully created.' }\n format.json { render json: @customer_price, status: :created, location: @customer_price }\n else\n format.html { render action: \"new\" }\n format.json { render json: @customer_price.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @purchase = Purchase.new(params[:purchase])\n\n respond_to do |format|\n if @purchase.save\n count = 0\n purchases_data = Array.new(@purchase.quantity).map do |e|\n count += 1\n { \"id\" => @purchase.order_id,\n \"productId\" => @purchase.product.id,\n \"productName\" => @purchase.product.name,\n \"customerId\" => 150,\n \"customerFirstName\" => \"Olle\",\n \"customerLastName\" => \"Martensson\" }\n end\n send_data({\"batch-id\" => @purchase.order_id, \"purchases\" => purchases_data }.to_json)\n\n format.html { redirect_to products_path, notice: \"Thank you for your purchase of #{pluralize(@purchase.quantity, \"unit\")} of \\\"#{@purchase.product.name}\\\"! (order id ##{@purchase.order_id})\" }\n format.json { render json: @purchase, status: :created, location: @purchase }\n else\n format.html { render action: \"new\" }\n format.json { render json: @purchase.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @caterogry = Caterogry.new(caterogry_params)\n\n respond_to do |format|\n if @caterogry.save\n format.html { redirect_to @caterogry, notice: 'Caterogry was successfully created.' }\n format.json { render :show, status: :created, location: @caterogry }\n else\n format.html { render :new }\n format.json { render json: @caterogry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @prod_coti = ProdCoti.new(prod_coti_params)\n\n respond_to do |format|\n if @prod_coti.save\n format.html { redirect_to @prod_coti, notice: 'Prod coti was successfully created.' }\n format.json { render :show, status: :created, location: @prod_coti }\n else\n format.html { render :new }\n format.json { render json: @prod_coti.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /product_cates/1 DELETE /product_cates/1.json
|
def destroy
@product_cate.destroy
respond_to do |format|
format.html { redirect_to product_cates_url, notice: 'Product cate was successfully destroyed.' }
format.json { head :no_content }
end
end
|
[
"def destroy\n @client_product.destroy\n respond_to do |format|\n format.html { redirect_to @client, notice: 'Custom price was successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @productos_json.destroy\n respond_to do |format|\n format.html { redirect_to productos_jsons_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @prod_of_nec.destroy\n respond_to do |format|\n format.html { redirect_to prod_of_necs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @est_prod_of_nec.destroy\n respond_to do |format|\n format.html { redirect_to est_prod_of_necs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contract_consumption = ContractConsumption.find(params[:id])\n @contract_consumption.destroy\n\n respond_to do |format|\n format.html { redirect_to contract_consumptions_url(:contract_product_id => @contract_consumption.contract_product_id) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cold_consumption = ColdConsumption.find(params[:id])\n @cold_consumption.destroy\n\n respond_to do |format|\n format.html { redirect_to cold_consumptions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @line_product = LineProduct.find(params[:id])\n @line_product.destroy\n\n respond_to do |format|\n format.html { redirect_to line_products_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @onecompany_product = Onecompany::Product.find(params[:id])\n @onecompany_product.destroy\n\n respond_to do |format|\n format.html { redirect_to onecompany_products_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @product = Product.find(params[:id])\n \n if @product.destroy\n render json: @product, :status => :ok\n else\n render json: @product, :status => '500'\n end\n end",
"def destroy\n @contract_product.destroy\n\n respond_to do |format|\n format.html { redirect_to contract_products_url(:contract_id => @contract_product.contract_id) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @product_datum.destroy\n respond_to do |format|\n format.html { redirect_to product_data_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @producte_dapcons.destroy\n respond_to do |format|\n format.html { redirect_to producte_dapcons_index_url, notice: 'Producte dapcons was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @discounts_product.destroy\n respond_to do |format|\n format.html { redirect_to discounts_products_url, notice: 'Discounts product was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @product_rec = ProductRec.find(params[:id])\n @product_rec.destroy\n\n respond_to do |format|\n format.html { redirect_to product_recs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @product_productcla_ref.destroy\n respond_to do |format|\n format.html { redirect_to product_productcla_refs_url, notice: 'Product productcla ref was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @prod_coti.destroy\n respond_to do |format|\n format.html { redirect_to prod_cotis_url, notice: 'Prod coti was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cliente_producto = ClienteProducto.find(params[:id])\n @cliente_producto.destroy\n\n respond_to do |format|\n format.html { redirect_to cliente_productos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @productline = Productline.find(params[:id])\n @productline.destroy\n\n respond_to do |format|\n format.html { redirect_to productlines_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @product_cach.destroy\n respond_to do |format|\n format.html { redirect_to product_caches_url, notice: 'Product cache was successfully destroyed.' }\n format.json { head :no_content }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Add or change an asset id in the asset id cache. This can be used for SASS on Heroku. :api: public
|
def add_to_asset_ids_cache(source, asset_id)
self.asset_ids_cache_guard.synchronize do
self.asset_ids_cache[source] = asset_id
end
end
|
[
"def rails_asset_id(source)\n if asset_id = ENV[\"RAILS_ASSET_ID\"]\n asset_id\n else\n if self.cache_asset_ids && (asset_id = self.asset_ids_cache[source])\n asset_id\n else\n path = File.join(config.assets_dir, source)\n asset_id = File.exist?(path) ? File.mtime(path).to_i.to_s : ''\n\n if self.cache_asset_ids\n add_to_asset_ids_cache(source, asset_id)\n end\n\n asset_id\n end\n end\n end",
"def rails_asset_id(source)\n if asset_id = ENV[\"RAILS_ASSET_ID\"]\n asset_id\n else\n if @@cache_asset_timestamps && (asset_id = @@asset_timestamps_cache[source])\n asset_id\n else\n path = File.join(ASSETS_DIR, source)\n asset_id = File.exist?(path) ? File.mtime(path).to_i.to_s : ''\n\n if @@cache_asset_timestamps\n @@asset_timestamps_cache_guard.synchronize do\n @@asset_timestamps_cache[source] = asset_id\n end\n end\n\n asset_id\n end\n end\n end",
"def rails_asset_id(source)\n asset_id = ENV[\"RAILS_ASSET_ID\"]\n return asset_id if asset_id\n return asset_id if @@cache_asset_timestamps && (asset_id = @@asset_timestamps_cache[source])\n\n path = Rails.root.join('public', source).to_s\n asset_id = File.exist?(path) ? File.mtime(path).to_i.to_s : ''\n\n if @@cache_asset_timestamps\n @@asset_timestamps_cache_guard.synchronize do\n @@asset_timestamps_cache[source] = asset_id\n end\n end\n\n asset_id\n end",
"def asset_param_key\n :id\n end",
"def asset_param_key\n :id\n end",
"def rails_asset_id source\r\n path = File.join(Rails.root, 'public', source)\r\n File.exist?(path) ? File.mtime(path).to_i.to_s : ''\r\n end",
"def asset_from_cache(key); end",
"def generate_cache_id; end",
"def fix_rails_asset_cache(asset_name)\n if ActionView::Helpers::AssetTagHelper.cache_asset_timestamps\n timestamps_cache = self.class.send(:class_variable_get, :@@asset_timestamps_cache)\n timestamps_guard = self.class.send(:class_variable_get, :@@asset_timestamps_cache_guard)\n\n timestamps_guard.synchronize do \n asset_id = timestamps_cache[asset_name]\n timestamps_cache.delete(asset_name) if asset_id == ''\n end\n end\n end",
"def cache (name, obj)\n if obj && obj.respond_to?(:id)\n self.cached_ids[name] = obj.id\n end\n obj\n end",
"def cache_id; end",
"def find_asset_by_id(id)\n assets[id]\n end",
"def cache_key(id); end",
"def install_asset_id=(asset_id)\n asset = Asset.find_by_guid(asset_id)\n hist = AssetOnSegmentHistory.create()\n asset_on_segment_historys << hist\n hist.install(asset)\n asset.save\n AssetObserver.install(asset, hist)\n end",
"def rewrite_asset_path(source)\n asset_id = rails_asset_id(source)\n if asset_id.blank?\n source\n else\n source + \"?#{asset_id}\"\n end\n end",
"def cache\n self.class.store.store.set_resource(resource_key, id, self)\n end",
"def add_to_cache\n redis.hset 'identifiers', self.typed_id, item.typed_id\n redis.sadd 'identifier:' + item.typed_id, self.typed_id\n end",
"def assets_version\n ENV[\"RAILS_ASSET_ID\"] || ''\n end",
"def process_replace_asset_id(data)\n\t\tdata.each do |item|\n\t\t\tid = @user.assets_id_by_name(item[:name])\n\t\t\tif id\n\t\t\t\titem[:rplcstr] = id[:asset]\n\t\t\t\tputs item\n\t\t\t\tresponse = @user.process_find_and_replace(item)\n\t\t\t\t@user.lastfindreplace\n\t\t\t\tsleep 5\n\t\t\telse\n\t\t\t\tputs \"asset name #{item[:name]} does not exist\"\n\t\t\tend\n\t\tend\n\tend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Sort talks in descending order by duraion Find number of tracks needed, since we know the total duraion exactly And intialize tracks As per the Best fit algorithm, Fill each tracks by looping through sorted talks Do this till available talks become empty
|
def schedule_talks
until available_talks.empty?
Track.all.each do |track|
schedule_talks_for_track(track)
# When a track didn't fill exactly
# Removing already scheduled last element from track and
# Again trying for a exact match on available talks
# Not a perfect solution, But, It produces better result
# Kind of backtracking
backtrack_and_schedule_talks_for_track(track)
end
end
end
|
[
"def pack_talks\n\n @tracks << Track.new() # create first [0] Track object\n x = 0 # first object @tracks[0]\n\n @talks.each do |talk|\n\n # if it's morning session, set limit to 180min, otherwise to 240min\n len = get_max_length(x)\n\n # if the sum of Track's total length + current talk's length is less\n # than y minutes\n if @tracks[x].total_length + talk.length.to_i <= len\n\n # append talk to current Track\n @tracks[x].talks << talk\n\n # add current talk's length to Track's total length\n @tracks[x].total_length += talk.length.to_i\n\n else\n available_tracks = @tracks.dup.reject{|k| k == x}\n available_tracks.each_with_index do |track, index|\n\n # if it's morning session, set limit to 180min, otherwise to 240min\n len = get_max_length(index)\n\n if track.total_length + talk.length.to_i <= len\n\n # append talk to current Track\n track.talks << talk\n\n # add current talk's length to Track's total length\n track.total_length += talk.length.to_i\n break\n else\n # append a new Track to the conference\n @tracks << Track.new()\n\n # set the last element of the array as the current one\n x = @tracks.size - 1\n\n # append talk to current track\n @tracks[x].talks << talk\n\n # add current talk's length to Track's total length\n @tracks[x].total_length += talk.length.to_i\n break\n end\n\n end\n\n end # @talks.each\n\n end\n @tracks\n end",
"def find_most_played_songs\n top_songs_with_play_count_pair = self.lib.songs.reject do |song|\n #this line is describing records it will get rid of\n (!song.metadata.has_key?('play_count')) or (song.metadata['play_count'] == nil)\n end\n\n top_songs_played_sorted = top_songs_with_play_count_pair.sort do |a, b| \n b.metadata['play_count'].to_i <=> a.metadata['play_count'].to_i\n end\n\n top_songs_played = top_songs_played_sorted.first(5)\n song_names_of_top_played = top_songs_played.collect {|song| song.metadata['name']} \n end",
"def prepare_tracks(tracks, starting_index, bonus)\n \n last_index = starting_index\n\n # loop through every song in the track list in order, normalizing their sequence numbers\n tracks.values.select{|val| val[\"bonus\"] == bonus.to_s}.sort_by{ |a| a[\"Seq\"].to_i }.each_with_index do |b, i|\n\n last_index = starting_index + i\n\n # sequence in 10s\n b[\"Seq\"] = (last_index * 10).to_s \n\n # if there's no override song name, add in the real song name\n if b[\"SONGID\"].present? \n b[\"Song\"] = Song.find(b[\"SONGID\"].to_i).full_name if b[\"Song\"].empty?\n end\n\n b[:VersionNotes] = nil if b[:VersionNotes].strip.empty?\n \n end\n\n starting_index\n\n end",
"def related_songs\n unless self.spotify_track_id.nil?\n related_artists = self.spotify_track.artists.first.related_artists\n\n related_artists.shuffle[0..4].map do |artist|\n artist.top_tracks('IE').shuffle.first\n end.flatten\n else\n Array.new\n end\n\n\n end",
"def find_most_played_songs\n find_songs_by_value_for_key('play_count', true, false) \n end",
"def top_songs(n = 3)\n top_list = @tracks.sort_by {|s| s.play_count}.reverse\n return top_list[0..n-1].compact\n end",
"def top_played_champs\n @player_champs_list.sort_by{ |champ| -champ.total_games }\n end",
"def get_top_decades(tracks)\n decades_hash = Hash.new\n tracks.each do |track|\n release_date = track.album.release_date\n decade = \"#{release_date[0, 3]}0s\"\n\n if decades_hash.key?(decade)\n decades_hash[decade] += 1\n else\n decades_hash[decade] = 1\n end\n end\n\n top_three_decades = decades_hash.sort_by {|k,v| -v}.first(3)\n return top_three_decades\n end",
"def organize_talks(talks)\n h = Hash.new\n h[:past] = []\n h[:today] = []\n h[:later_this_week] = []\n (0..6).each { |wday| h[:later_this_week][wday] = [] }\n h[:next_week] = []\n (0..6).each { |wday| h[:next_week][wday] = [] }\n h[:beyond] = []\n\n h[:now] = Time.now\n\n the_past = (h[:now] - 1.day).end_of_day\n today = h[:now].beginning_of_day..h[:now].end_of_day\n later_this_week = (h[:now].beginning_of_day + 1.day)..((h[:now] + 1.day).end_of_week - 1.day)\n next_week = ((h[:now] + 1.day).beginning_of_week + 6.day)..((h[:now] + 1.day).end_of_week + 6.day)\n beyond = (h[:now] + 1.day).beginning_of_week + 13.day\n\n talks.each do |t|\n if t.start_time <= the_past\n h[:past] << t\n elsif today.cover? t.start_time\n h[:today] << t\n elsif later_this_week.cover? t.start_time\n h[:later_this_week][t.start_time.wday] << t\n elsif next_week.cover? t.start_time\n h[:next_week][t.start_time.wday] << t\n else\n h[:beyond] << t\n end\n end\n\n h[:past].sort! { |a,b| a.start_time <=> b.start_time }\n h[:today].sort! { |a,b| a.start_time <=> b.start_time }\n h[:later_this_week].each { |ts| ts.sort! { |a,b| a.start_time <=> b.start_time } }\n h[:next_week].each { |ts| ts.sort! { |a,b| a.start_time <=> b.start_time } }\n h[:beyond].sort! { |a,b| a.start_time <=> b.start_time }\n\n return h\n end",
"def compare_songs\n for i1 in 0...CP::OCARINA::SETTINGS::SONGS.size\n cur_note = 0\n note_same = 0\n for i2 in 0...CP::OCARINA::SETTINGS::SONGS[i1].size\n unless CP::OCARINA::SETTINGS::SONGS[i1][i2] == 0\n note_same += 1 if CP::OCARINA::SETTINGS::SONGS[i1][i2] == @play_notes[cur_note]\n cur_note += 1\n end\n end\n @play_song = i1 if note_same == @max_note and ($data_songs[i1][2] or @teach)\n @taught = true if @play_song == @t_song and @teach\n end\n @play_song = -1 if @teach and @taught == false\n if @taught\n $data_songs[@t_song][0] = CP::OCARINA::SETTINGS::NAMES[@t_song]\n $data_songs[@t_song][1] = CP::OCARINA::SETTINGS::DESCS[@t_song]\n $data_songs[@t_song][2] = true\n end\n end",
"def top_kd_champs\n @player_champs_list.sort_by do |champ|\n if champ.total_deaths > 0\n -(champ.total_kills.to_f / champ.total_deaths)\n else \n -(champ.total_kills.to_f) \n end\n end \n end",
"def populate(target_valence, num_songs)\n candidate_tracks = self.user.recommended_tracks(target_valence)\n track_weights = {}\n weights_sum = 0\n\n # Assign each track a weight, add it to the track_weights hash and calculate the sum of all the weights\n candidate_tracks.each do |track|\n # Calculate the weight of each track by finding the percentage difference between the target_valence and the track's valence\n diff = target_valence - track.valence\n percent_diff = diff.abs / ((target_valence + track.valence) / 2)\n percent_diff = 1 if percent_diff > 1\n\n # Tracks with a valence close to the target valence will have a weight near 1 and tracks with valence far away will have a weight near 0\n track_weights[track] = 1 - percent_diff\n weights_sum += track_weights[track]\n end\n\n # Select songs from the pool at semi-random and add them to the playlist\n num_songs.times do\n track = select_random_track(track_weights, weights_sum)\n # The following select method call is workaround for strange behaviour when calling track_weights[track] or track_weights.fetch(track) (both return nil even when track exists in track_weights)\n weights_sum -= track_weights.select{|t, w| t.id == track.id }.values[0]\n\n self.tracks << track\n track_weights.delete_if {|t, w| t.id == track.id }\n end\n end",
"def sort\n\t\t@track = Track.find_by_id(params[:methodParam][0]) \n\t\t@topic = @track.topic \n\t\t@tracks = @topic.tracks\n \t\tnew_Order_Array = params[:methodParam]\n\n\t\t@tracks.each do |track|\n\t\t\ttrack.difficulty = (params[:methodParam]).index(track.id.to_s) + 1\n\t\tend\n\t\trender :nothing => true\n\tend",
"def randomize\n original_list = tracks\n song_count = original_list.size\n attempt_threshold = (song_count * 0.33).floor # so we don't spin forever\n new_list = [original_list.shift]\n idx = 0\n until original_list.empty? do\n attempts = 0\n until attempts >= attempt_threshold || (original_list[idx] && new_list.last.artist != original_list[idx].artist)\n idx = rand(song_count) \n attempts +=1\n end\n new_list << original_list[idx]\n original_list.delete_at(idx) \n end\n# clear\n new_list\n end",
"def giveTopFive\n allMusics = []\n\n self.albums.each { |album|\n album.musics.each { |music|\n allMusics << { note: music.getAverageNote, object: music }\n }\n }\n\n allMusics.sort! { |a,b| b[:note] <=> a[:note] }\n return allMusics[0..5]\n end",
"def get_trial_suggestions\n case @last_played.size\n when 0\n load_trials({\n 'San Francisco' => :very_easy,\n 'The Bunker' => :very_easy,\n 'Caravel Ships' => :easy,\n })\n when 1\n load_trials({\n 'San Francisco' => :very_easy,\n 'The Bunker' => :very_easy,\n 'Caravel Ships' => :easy,\n 'Tower in the Castle' => :medium,\n })\n when 2\n load_trials({\n 'San Francisco' => :very_easy,\n 'Caravel Ships' => :very_easy,\n 'Tower in the Castle' => :easy,\n 'Cat Mountain Climb' => :medium,\n 'Moonlit Woods' => :medium,\n })\n when 3\n load_trials({\n 'San Francisco' => :very_easy,\n 'Tower in the Castle' => :easy,\n 'Cat Mountain Climb' => :easy,\n 'Moonlit Woods' => :easy,\n 'Egypt Pyramid' => :medium,\n 'The Cave' => :medium,\n })\n when 4\n load_trials({\n 'Tower in the Castle' => :very_easy,\n 'Cat Mountain Climb' => :easy,\n 'Moonlit Woods' => :easy,\n 'Egypt Pyramid' => :medium,\n 'The Cave' => :medium,\n 'Cyberpunk Ruins' => :hard,\n 'Steamport Town' => :hard,\n })\n when 5\n load_trials({\n 'Cat Mountain Climb' => :very_easy,\n 'Moonlit Woods' => :easy,\n 'Egypt Pyramid' => :easy,\n 'The Cave' => :easy,\n 'Cyberpunk Ruins' => :medium,\n 'Steamport Town' => :medium,\n 'Find the Dragon' => :hard,\n 'Star Hopping' => :hard,\n })\n when 6\n load_trials({\n 'Cat Mountain Climb' => :very_easy,\n 'Moonlit Woods' => :very_easy,\n 'Egypt Pyramid' => :easy,\n 'The Cave' => :easy,\n 'Cyberpunk Ruins' => :medium,\n 'Steamport Town' => :medium,\n 'Find the Dragon' => :hard,\n 'Star Hopping' => :hard,\n 'Shadow of Valus' => :very_hard,\n 'The Cube' => :very_hard,\n })\n when 7\n load_trials({\n 'Tower in the Castle' => :easy,\n 'Moonlit Woods' => :very_easy,\n 'Egypt Pyramid' => :easy,\n 'The Cave' => :easy,\n 'Cyberpunk Ruins' => :medium,\n 'Steamport Town' => :medium,\n 'Find the Dragon' => :hard,\n 'Star Hopping' => :hard,\n 'Shadow of Valus' => :very_hard,\n 'The Cube' => :very_hard,\n 'Temple City' => :very_hard,\n })\n else\n nil # if user already played more than 6 games, then return nil (will get delegated to get_standard_suggestions)\n end\n end",
"def final_results_list\n winners = sort_group_of_teams(self.teams.select { |team| team.playoffs && team.court_id == 100 })\n losers = sort_group_of_teams(self.teams.select { |team| team.playoffs && team.court_id != 100 })\n\n #only for kob, game play will not have a losers court\n ## winner of consolation court kob, become overall 4th place\n if (losers)\n third_place = losers.shift\n winners.insert(3, third_place).concat(losers)\n end\n winners\n end",
"def sorting()\n #makes sure that /a/ quarter is selected\n @quater = params[:quater]\n @quater == nil ? @quater = 'Q1' : @quater = @quater\n\n #REVIEW this is for clearing the teams not in the quater out of teams. Its done 7 times becuase for some reason it doesnt catch all the teams unless if its repeated\n 7.times {@teams.each {|team| team_in_quater(team, @quater) ? a=0 : @teams.delete(team)}}\n\n if params[:search]\n #REVIEW it does the same thing down here and for every time it iterates, half of the deletes are successful\n 7.times {search(@teams, params[:search])}\n end\n\n #finding the param that organizes team index by overall investment\n if params[:Investment] == 'ascending'\n team_investments = find_team_values()\n #sorts the teams hash from lowest to highest\n @teams.sort! {|x,y| team_investments[x.id] <=> team_investments[y.id] }\n #this does the same thing but ends up sorting from highest to lowest\n elsif params[:Investment] == 'descending'\n team_investments = find_team_values()\n @teams.sort! {|x,y| team_investments[y.id] <=> team_investments[x.id] }\n end\n\n #this finds the param for team name and sorts it (team 1 -> team 2 -> team 10 -> team 12 -> etc)\n if params[:Name] == 'ascending'\n @teams.sort! {|x,y| sorting_function(x.name, y.name) }\n elsif params[:Name] == 'descending'\n @teams.sort! {|x,y| sorting_function(y.name, x.name) }\n end\n\n if params[:Investment_f]\n team_investments = find_team_values()\n if params[:Investment_f].to_i > 100\n 7.times {@teams.each {|team,value| (100 < team_investments[team.id]) ? a = 0 : @teams.delete(team)}}\n else\n 7.times {@teams.each {|team,value| ((params[:Investment_f].to_i..params[:Investment_f].to_i+9).include? team_investments[team.id]) ? a = 0 : @teams.delete(team) }}\n end\n end\n\n #this paginates the teams into 15 per page\n @teams = @teams.paginate(:page => params[:page], :per_page => 15)\n end",
"def song_sorter(arr1, arr2, arr3)\n sorted_songs = {}\n\n (arr1 + arr2 + arr3).each do |classifier|\n song = classifier.song\n sorted_songs[song] ? sorted_songs[song] += 1 : sorted_songs[song] = 1\n end\n\n result = {\n first_recommendation: [],\n second_recommendation: [],\n third_recommendation: []\n }\n\n sorted_songs.each do |song, value|\n # TODO: Come back to this when you have async figured out\n # RecommendedSong.create(song_id: song.id,\n # recommendation_id: @recommendation.id)\n case value\n when 3\n result[:first_recommendation] << song\n when 2\n result[:second_recommendation] << song\n when 1\n result[:third_recommendation] << song\n end\n end\n\n result\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Return true if canceled this task ==== Return true if canceled this task
|
def canceled?
@state == :cancel
end
|
[
"def canceled?\n @__status == TaskStatus::CANCELED\n end",
"def cancel\n warn(\"Cancelling task #{name}...\")\n self.status = :canceled\n stopped?\n end",
"def cancelled?\n cancelled\n end",
"def cancelled?\n return @cancelled\n end",
"def canceled_by?(event)\n return false\n end",
"def cancelled?\n !@call.status.nil? && @call.status.code == Core::StatusCodes::CANCELLED\n end",
"def cancelled?\n status_code == 'ABORT'\n end",
"def is_cancelled\n return @is_cancelled\n end",
"def cancelled?\n status_code == 'ABORT'\n end",
"def cancel?\n self.type == :cancel\n end",
"def from_canceled\n task = Task.new\n task.__status = TaskStatus::CANCELED\n task\n end",
"def cancel?\n self.action == :cancel\n end",
"def cancel?\n self.state == CANCEL\n end",
"def is_canceled?\n return self.status == Erp::QuickOrders::Order::STATUS_CANCELED\n end",
"def cancellation_pending?\n if self.state_changed?\n before_after_states = self.state_change.map { |st| st.nil? ? nil : st.to_sym }\n \n # It would be nice if Ruby could do pattern matching (like in Elixir and Scala).\n # We could sure use it here.\n if before_after_states[1] == :canceled\n true\n elsif (before_after_states[0] != :awaiting_sale_docs) && (before_after_states[1] == :ready_for_seller_billing)\n true\n else\n false\n end\n else\n false\n end\n end",
"def cancel? id\n result = false\n @cancel_semaphore.synchronize { result = @cancel.include? id }\n result\n end",
"def cancelled?\n Sidekiq.redis { |c| c.exists(\"cancelled-#{jid}\") }\n end",
"def cancel?(id); end",
"def is_cancelled?\n\n if fe = fexp\n return fe.h.state == 'cancelling'\n else\n true\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `gradle_task`, returning 'spotbugsRelease' if value is nil.
|
def gradle_task
@gradle_task ||= 'spotbugsRelease'
end
|
[
"def gradle_task\n @gradle_task ||= 'pmd'\n end",
"def gradle_task\n @gradle_task ||= \"ktlintCheck\"\n end",
"def gradle_task\n @gradle_task ||= \"lint\"\n end",
"def get_task(task_name)\n if using_rake? and task_defined?(task_name)\n Rake::Task[task_name]\n end\n end",
"def gradle_task\n @gradle_task ||= 'jacoco'\n end",
"def get_release(project)\n info = get_github_api(project, \"releases\")\n release = 'master'\n if info.length > 0\n unpublishedDraftLimit = 5\n x = 0\n release = info[x]['tag_name']\n # Unpublished drafts need to be skipped.\n while (unpublishedDraftLimit > x) && info[x]['draft']\n release = info[x]['tag_name']\n x += 1\n end\n end\n release\n end",
"def _get_release_number\n version.release\n end",
"def gradle_version\n @gradle_version ||= begin\n version = Licensed::Shell.execute(@executable, \"--version\").scan(/Gradle [\\d+]\\.[\\d+]/).last.split(\" \").last\n Gem::Version.new(version)\n end\n end",
"def task\n project.tasks.find do |task|\n task.name == options[\"task\"]\n end\n end",
"def sonar_task_id\n @sonar_task_id ||= task_id(@options['sonar_task_name'] || 'Sonar Plugin')\n end",
"def gradle_module\n @gradle_module ||= 'app'\n end",
"def project_from_task(task) #:nodoc:\n project = Buildr.application.lookup('rake:' + task.to_s.gsub(/:[^:]*$/, ''))\n project if Project === project\n end",
"def current_task_name\n return nil unless enabled?\n self.class.current_task_name\n end",
"def task_class\n map = {\n :build => Texas::Build::Final,\n :dry => Texas::Build::Dry,\n }\n map[@options.task] || fallback_task_class\n end",
"def is_buildable?(task_name)\n @logger.info \"Checking if task '#{task_name}' from the build queue\" +\n \" is buildable\"\n buildable = nil\n details = get_details(task_name)\n unless details.empty?\n buildable = details[\"buildable\"]\n end\n buildable\n end",
"def safe_task_name(timing)\n timing.task.present? ? timing.task.name : \"n/a\"\n end",
"def getTaskName\r\n\t\t\t\t\treturn @taskName\r\n\t\t\t\tend",
"def get_task(name)\n return Rake.application[name]\n end",
"def rake_task_name\n ENV['RAKE_TASK'].to_s.sub(/(?:r?spec|cucumber):?(.*)/, '\\1').upcase\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `skip_gradle_task`, returning false if value is nil.
|
def skip_gradle_task
@skip_gradle_task ||= false
end
|
[
"def excluded_task?(task)\n @tasks.include?(task)\n end",
"def ignore_force?(task)\n !(metadata[\"run_#{task}\"].nil? || metadata[\"run_#{task}\"])\n end",
"def skip?\n !!current_model.try(:skip?)\n end",
"def ignore_task?(task)\n return true unless is_active?\n return !metadata[\"run_#{task}\"] unless metadata[\"run_#{task}\"].nil?\n return true if task==:taxonomy and project.metadata[:ref_project].nil?\n pattern = [true, false]\n ( [@@_EXCLUDE_NOREF_TASKS_H[task], is_ref? ]==pattern or\n [@@_ONLY_MULTI_TASKS_H[task], is_multi? ]==pattern or\n [@@_ONLY_NONMULTI_TASKS_H[task], is_nonmulti?]==pattern )\n end",
"def should_skip\n if @needed.nil?\n @needed = prerequisite_tasks.empty? || \\\n input_files.since(@last_executed).any? || \\\n @force\n\n # We also make sure that if the rakefile was modified since last\n # execution, we force reexecution\n if @application.rakefile\n @needed ||= File.mtime(@application.rakefile) > @last_executed\n end\n end\n !@needed\n end",
"def ignore_task?(task)\n return !metadata[\"run_#{task}\"] unless metadata[\"run_#{task}\"].nil?\n return true if task==:taxonomy and project.metadata[:ref_project].nil?\n pattern = [true, false]\n ( [@@_EXCLUDE_NOREF_TASKS_H[task], is_ref? ]==pattern or\n [@@_ONLY_MULTI_TASKS_H[task], is_multi? ]==pattern or\n [@@_ONLY_NONMULTI_TASKS_H[task], is_nonmulti?]==pattern )\n end",
"def skipped?\n !!@skipped\n end",
"def skip?\n not (@only_if.nil? or !!(@only_if.value))\n end",
"def skipped?\n @skipped\n end",
"def skipped?\n !@test_case.search('./skipped').empty?\n end",
"def skipping\n defined?(@skipping) ? @skipping : nil\n end",
"def skip_gitignore?\n skip = false\n return @config['skip_gitignore'] if @config.key? 'skip_gitignore'\n\n skip\n end",
"def gradle_task\n @gradle_task ||= 'pmd'\n end",
"def skip_comments?\n @skip_comments\n end",
"def gradle_task\n @gradle_task ||= \"ktlintCheck\"\n end",
"def InTaskHierarchy?()\n return @ProjectFile != nil\n end",
"def run_task?\n true\n end",
"def should_skip\n false\n end",
"def has_task?(task_name)\n !self[task_name.to_s].nil?\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `root_path`, returning result of `git revparse showtoplevel` if value is nil.
|
def root_path
@root_path ||= `git rev-parse --show-toplevel`.chomp
end
|
[
"def repository_root\n return unless available?\n root = Licensed::Shell.execute(\"git\", \"rev-parse\", \"--show-toplevel\", allow_failure: true)\n return nil if root.empty?\n root\n end",
"def root\n Pathname.new `git rev-parse --show-toplevel`.chomp\n end",
"def raw_toplevel\n\t\t\twith_dir do\n\t\t\t\treturn Pathname.new(%x/git rev-parse --show-toplevel/.chomp)\n\t\t\tend\n\t\tend",
"def git_root\n git_dir = `git rev-parse --show-toplevel`.strip\n raise \"Error: not a git repository\" if git_dir.empty?\n\n git_dir\nend",
"def lookup_root\n root = nil\n Dir.ascend(Dir.pwd) do |path|\n check = Dir[ROOT_GLOB].first\n if check\n root = path \n break\n end\n end\n root || Dir.pwd\n end",
"def git_root_till_home\n Pathname.new(Dir.pwd).ascend do |dir_pathname|\n return dir_pathname if File.directory?(\"#{dir_pathname}/.git\")\n return nil if dir_pathname.to_s == home_dir\n end\n end",
"def root(path = nil)\n if path\n @root = Pathname.new(path).expand_path\n else\n @root\n end\n end",
"def get_root_directory\n return @@root_directory\n end",
"def repo_root\n @repo_root ||=\n begin\n result = execute(%w[git rev-parse --show-toplevel])\n unless result.success?\n raise Overcommit::Exceptions::InvalidGitRepo,\n 'Unable to determine location of GIT_DIR. ' \\\n 'Not a recognizable Git repository!'\n end\n result.stdout.chomp(\"\\n\")\n end\n end",
"def top_level\n git.git_dir.chomp(GIT_DIR)\n end",
"def root_path\n environment.paths.detect { |path| pathname.to_s[path] }\n end",
"def find_control_repo_root(strict_check = false)\n environment_conf_path = PDK::Util.find_upwards('environment.conf')\n path = if environment_conf_path\n File.dirname(environment_conf_path)\n elsif control_repo_root?(Dir.pwd)\n Dir.pwd\n else\n nil\n end\n return path if path.nil? || !strict_check\n PDK::Bolt.bolt_project_root?(path) ? nil : path\n end",
"def root\n @root ||= begin\n if defined?(Rails)\n File.join Rails.root\n else\n \"./\"\n end\n end\n end",
"def find_control_repo_root(strict_check = false)\n environment_conf_path = PDK::Util.find_upwards('environment.conf')\n path = if environment_conf_path\n File.dirname(environment_conf_path)\n elsif control_repo_root?(Dir.pwd)\n Dir.pwd\n end\n return path if path.nil? || !strict_check\n\n PDK::Bolt.bolt_project_root?(path) ? nil : path\n end",
"def root\n Dir.pwd.split(File::SEPARATOR).first\n end",
"def getRoot\n @path[0]\n end",
"def root(path = nil)\n base = Deployinator.root_dir\n path ? File.join(base, path) : base\n end",
"def root_path\n return @root_path if defined?(@root_path)\n\n root_finder = lambda do |path|\n # Note: To remain compatible with Ruby 1.8, we have to use\n # a `find` here instead of an `each`.\n found = vagrantfile_name.find do |rootfile|\n File.exist?(File.join(path.to_s, rootfile))\n end\n\n return path if found\n return nil if path.root? || !File.exist?(path)\n root_finder.call(path.parent)\n end\n\n @root_path = root_finder.call(cwd)\n end",
"def root path = nil\n if path && configurable?\n @root = normalize_path(path)\n # resetting path to an empty string cause root should be an absolute path to templates.\n @path, @setup[:path] = nil\n path ''\n end\n @setup[:root] ||= @root ||\n (@controller.ctrl.slice.view.root if @controller) ||\n Presto::App.root\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `report_file`, returning 'app/build/reports/spotbugs/release.xml' if value is nil.
|
def report_file
@report_file ||= 'app/build/reports/spotbugs/release.xml'
end
|
[
"def report_file\n return @report_file || \"build/reports/detekt/detekt.xml\"\n end",
"def report_file\n @report_file ||= 'app/build/reports/pmd/pmd.xml'\n end",
"def report_file\n @report_file ||= 'build/reports/jacoco/jacoco/jacoco.xml'\n end",
"def report_to\n @report_to ||= file(@project.path_to(:reports, framework)=>self)\n end",
"def build_report_path\n File.join(log_dir, BUILD_REPORT_BASENAME)\n end",
"def file_name_xunit_report\n Pathname.new 'report.xml'\n end",
"def report_uri\n @report_uri ||= case (value = @node['reportUri'])\n when nil, 'None' then nil\n else value\n end\n end",
"def report_path(name)\n return File.join(@export_dir, @reports_dir) if name.nil?\n\n File.join(@export_dir, @reports_dir, name)\n end",
"def file_path_xunit_report\n Noop::Config.dir_path_reports + file_name_xunit_report\n end",
"def report_file\n File.join(@report_dir, \"#{@id}.json\")\n end",
"def report_file_path\n task.report_file_path action\n end",
"def report\n return ENV['TM_FLEXPMD_REPORT'] unless ENV['TM_FLEXPMD_REPORT'].nil?\n ENV['TM_PROJECT_DIRECTORY']+'/report/flexpmd/pmd.xml'\n end",
"def spotbugs_report(report_file)\n require 'oga'\n Oga.parse_xml(File.open(report_file))\n end",
"def task_file\n @task_file || \".sonar/report-task.txt\"\n end",
"def report_name\n return @report_name\n end",
"def report_record\n self.report_file\n end",
"def report_file_path(action)\n task_report_dir = File.join Deploy::Config[:report_dir], name\n unless File.exists? task_report_dir\n require 'fileutils'\n FileUtils.mkdir_p task_report_dir\n end\n raise \"No directory #{task_report_dir} for report!\" unless File.directory? task_report_dir\n File.join task_report_dir, action.to_s + '.' + Deploy::Config[:report_extension]\n end",
"def release_file\n File.join(source_dir, \".release\")\n end",
"def default_rep\n return ENV['TM_FLEXPMD_REPORT'] unless ENV['TM_FLEXPMD_REPORT'].nil?\n ENV['TM_PROJECT_DIRECTORY']+'/report/flexpmd/pmd.xml'\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `report_files`, returning ['app/build/reports/spotbugs/release.xml'] if value is nil.
|
def report_files
@report_files ||= [report_file]
end
|
[
"def report_file\n @report_file ||= 'app/build/reports/spotbugs/release.xml'\n end",
"def report_file\n return @report_file || \"build/reports/detekt/detekt.xml\"\n end",
"def ed_reports\n Dir.children(path).select{ |fn| fn.end_with?('editor_report.xls') }\n end",
"def get_files\n files = []\n files.push @version_file if @version_file\n files.push components.flat_map(&:files)\n files.flatten.uniq\n end",
"def get_report_templates\n report_templates = []\n changesets.each do |revision|\n revision.filechanges.each do |change|\n report_templates += [change.path] if (change.path.index(Setting.plugin_redmine_build_version['report_template_substring']))\n end\n end\n report_templates.compact.uniq.sort_by { |x| x.downcase }\n end",
"def ls_report_dir(branch = proj_branch)\n files = proj.show(report_branch, report_path(branch)).split(\"\\n\")\n files.shift(2)\n files\n end",
"def report_file\n @report_file ||= 'app/build/reports/pmd/pmd.xml'\n end",
"def file_path_xunit_report\n Noop::Config.dir_path_reports + file_name_xunit_report\n end",
"def upload_dirs\n self.reports.collect {|report| File.dirname(report.name)}.sort.uniq\n end",
"def files_dir\n File.absolute_path(File.join(@root_dir, 'lib/urbanopt/reporting/default_reports/'))\n end",
"def get_report_documents_by_name(document_name)\n return self.report_files.blobs.where(filename: document_name).to_a\n end",
"def report_to\n @report_to ||= file(@project.path_to(:reports, framework)=>self)\n end",
"def get_report_uris(report_filter)\n return [] if report_filter == NONE_REPORT_FILTER\n\n interpolate_local_report_uris(@config.report_uris)\n end",
"def plugin_files\n files = []\n @plugin.packagedata.each do |name, data|\n files += data[:files].reject{ |f| File.directory?(f) }\n end\n files\n end",
"def report_errors\n if !@latest.nil? and !@latest[:report_errors].nil?\n return @latest[:report_errors]\n else\n return []\n end\n end",
"def getOutputFiles\n if (self.getCompleted)\n file_list = JSON.parse(@client[\"/StatsDownloadUrls?loadTestId=#{@test_id}\"].get)['outputFiles']\n if (file_list && file_list.length == @server_cnt)\n file_list\n end\n end\n end",
"def file_entries\n entries.select{|entry| entry.file?}\n end",
"def files_list\n return FileAdapter.files_list(package_location, package_name)\n end",
"def report_trackers\n self.class.report_definer.trackers# => rescue []\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Calls SpotBugs task of your Gradle project. It fails if `gradlew` cannot be found inside current directory. It fails if `report_file` cannot be found inside current directory. It fails if `report_files` is empty.
|
def report(inline_mode: true)
unless skip_gradle_task
raise('Could not find `gradlew` inside current directory') unless gradlew_exists?
exec_gradle_task
end
report_files_expanded = Dir.glob(report_files).sort
raise("Could not find matching SpotBugs report files for #{report_files} inside current directory") if report_files_expanded.empty?
do_comment(report_files_expanded, inline_mode)
end
|
[
"def lint\n unless gradlew_exists?\n fail(\"Could not find `gradlew` inside current directory\")\n return\n end\n\n unless SEVERITY_LEVELS.include?(severity)\n fail(\"'#{severity}' is not a valid value for `severity` parameter.\")\n return\n end\n\n system \"./gradlew #{gradle_task || 'lint'}\"\n\n unless File.exists?(report_file)\n fail(\"Lint report not found at `#{report_file}`. \"\\\n \"Have you forgot to add `xmlReport true` to your `build.gradle` file?\")\n end\n\n issues = read_issues_from_report\n filtered_issues = filter_issues_by_severity(issues)\n\n message = message_for_issues(filtered_issues)\n markdown(message) unless filtered_issues.empty?\n end",
"def report(inline_mode: true)\n unless skip_gradle_task\n raise('Could not find `gradlew` inside current directory') unless gradlew_exists?\n\n exec_gradle_task\n end\n\n report_files_expanded = Dir.glob(report_files).sort\n raise(\"Could not find matching PMD report files for #{report_files} inside current directory\") if report_files_expanded.empty?\n\n do_comment(report_files_expanded, inline_mode)\n end",
"def report(file = nil)\n # Check that swiftlint is in the user's PATH\n # raise \"swiftlint is not in the user's PATH, or it failed to install\" unless swiftlint_installed?\n unless swiftlint_installed?\n fail \"swiftlint is not in the user's PATH, or it failed to install\"\n return\n end\n\n # Create a report file if none is provided\n file = generate_report if file == nil\n\n # Gather JSON from the report to process\n report_json = get_report_json file\n\n # No need to create a report if there are no issues\n return if report_json.length == 0\n\n # Assumes this is being run in the root of the repo, using PWD to find the relative path of repo files\n commit_path = path_for_commit\n issues = ''\n report_json.each do |entry|\n type = entry['severity'].downcase.to_sym\n next unless enabled_types.include? type\n\n line = entry['line']\n report_filename = entry['file']\n repo_file_path = repo_path report_filename\n issue_path = issue_path commit_path, repo_file_path, line\n reason = entry['reason']\n\n issues << \"| #{issue_emoji[type]} | [#{repo_file_path} (line #{line})](#{issue_path}) | #{reason} |\\n\"\n end\n\n show_report issues\n end",
"def check_report_file\n self.report_dir = File.expand_path(path)\n report_config_file = File.join(report_dir, Hastie2.report_config_name)\n if !File.exists? report_config_file\n say_status \"error\",\"Cannot locate #{Hastie2.report_config_name}.\", :red\n say_status \"error\",\"Directory #{self.report_dir} is not a report.\", :red\n exit(1)\n end\n end",
"def spotbugs_report(report_file)\n require 'oga'\n Oga.parse_xml(File.open(report_file))\n end",
"def report_file\n @report_file ||= 'app/build/reports/spotbugs/release.xml'\n end",
"def report\n ktlint_report_file_complete = \"#{Dir.pwd}/#{ktlint_report_file}\"\n detekt_report_file_complete= \"#{Dir.pwd}/#{detekt_report_file}\"\n\n check_file_integrity(ktlint_report_file_complete)\n check_file_integrity(detekt_report_file_complete)\n\n ktlint_issues = read_issues_from_report(ktlint_report_file)\n detekt_issues = read_issues_from_report(detekt_report_file)\n\n report_issues(ktlint_issues)\n report_issues(detekt_issues)\n end",
"def build_report\n if `#{option(:file_to_run)}` =~ /: (\\d*)$/\n report 'count' => $1.to_i\n else\n raise \"Couldn't run `bat file` as expected.\"\n end\n rescue Exception\n error \"Error running bat file\", $!.message\n end",
"def lint(inline_mode: false)\n unless skip_gradle_task\n return fail(\"Could not find `gradlew` inside current directory\") unless gradlew_exists?\n end\n\n unless skip_gradle_task\n if use_staged_file_only\n targets = target_files(git.added_files + git.modified_files)\n system \"./gradlew #{gradle_task} -PinternalKtlintGitFilter=\\\"#{targets.join('\\n')}\\\"\" #todo make it work\n else\n system \"./gradlew #{gradle_task}\"\n end\n end\n\n json_files = report_file.split(',')\n results = []\n json_files.each do |jsonFile|\n unless File.exists?(jsonFile)\n next\n end\n results += JSON.parse(File.read(jsonFile))\n end\n if results.empty?\n print(\"Skipping ktlinting because no report files available\")\n end\n\n if inline_mode\n send_inline_comments(results)\n else\n send_markdown_comment(results)\n end\n end",
"def lint\n report_file = @report_file || \"app/build/reports/pmd/pmd.xml\"\n project_root = @project_root || Dir.pwd\n\n puts report_file\n doc = File.open(report_file) { |f| Nokogiri::XML(f) }\n doc.xpath(\"//file\").each { |file| \n file.xpath(\"//violation\").each { |violation| \n warning_text = violation.content\n warning_line = violation.attr(\"beginline\")\n warning_file = file.attr(\"name\").sub(project_root + \"/\", \"\")\n\n warn(warning_text, file: warning_file, line: warning_line) \n }\n }\n end",
"def lint(inline_mode: false)\n unless skip_gradle_task\n return fail(\"Could not find `gradlew` inside current directory\") unless gradlew_exists?\n end\n\n unless SEVERITY_LEVELS.include?(severity)\n fail(\"'#{severity}' is not a valid value for `severity` parameter.\")\n return\n end\n\n unless skip_gradle_task\n system \"./gradlew #{gradle_task}\"\n end\n\n unless File.exist?(report_file)\n fail(\"Lint report not found at `#{report_file}`. \"\\\n \"Have you forgot to add `xmlReport true` to your `build.gradle` file?\")\n end\n\n issues = read_issues_from_report\n filtered_issues = filter_issues_by_severity(issues)\n\n message = \"\"\n\n if inline_mode\n # Report with inline comment\n send_inline_comment(filtered_issues)\n else\n message = message_for_issues(filtered_issues)\n markdown(\"### AndroidLint found issues\\n\\n\" + message) unless message.to_s.empty?\n end\n\n message\n end",
"def gradle_task\n @gradle_task ||= 'pmd'\n end",
"def analyse_sonar_report(files, options)\n issues = parse_sonar_report(options[:report])\n # Filter issues that are part of modified files\n issues = issues_in_files_patch(issues)\n end",
"def bug_report\n raise BakerError, <<-EOS\n Bug reporting has not yet been implimented.\n Manually send a bug report to #{@maintainer}.\n EOS\n end",
"def all_site_report(ticket_repository, options, helper,\n historical_scan_file = File.join(File.dirname(__FILE__), \"#{options[:file_name]}\"))\n log_message('First time run, generating full vulnerability report.') if @first_time\n log_message('No site(s) specified, generating full vulnerability report.') if options[:sites].empty?\n all_delta_vulns = ticket_repository.all_vulns(severity: options[:severity])\n log_message('Preparing tickets.')\n tickets = helper.prepare_create_tickets(all_delta_vulns)\n helper.create_tickets(tickets)\n log_message(\"Done processing, updating historical CSV file #{historical_scan_file}.\")\n ticket_repository.save_last_scans(historical_scan_file)\n log_message('Done updating historical CSV file, service shutting down.')\n end",
"def task_file\n @task_file || \".sonar/report-task.txt\"\n end",
"def gradle_task\n @gradle_task ||= 'spotbugsRelease'\n end",
"def lint_files\n # Installs SwiftLint if needed\n system \"brew install swiftlint\" unless swiftlint_installed?\n\n # Check that this is in the user's PATH after installing\n unless swiftlint_installed?\n fail \"swiftlint is not in the user's PATH, or it failed to install\"\n return\n end\n\n swiftlint_command = \"\"\n swiftlint_command += \"cd #{directory} && \" if directory\n swiftlint_command += \"swiftlint lint --quiet --reporter json\"\n swiftlint_command += \" --config #{config_file}\" if config_file\n\n require 'json'\n result_json = JSON.parse(`(#{swiftlint_command})`).flatten\n\n # Convert to swiftlint results\n warnings = result_json.select do |results|\n results['severity'] == 'Warning'\n end\n errors = result_json.select do |results|\n results['severity'] == 'Error'\n end\n\n # We got some error reports back from swiftlint\n if warnings.count > 0 || errors.count > 0\n message = ''\n\n message = \"### SwiftLint found issues\\n\\n\"\n message << parse_results(warnings, 'Warnings') unless warnings.empty?\n message << parse_results(errors, 'Errors') unless errors.empty?\n\n markdown message unless message.empty?\n end\n \n if fail_when_errors_exist && errors.count > 0\n fail(\"SwiftLint found #{errors.count} error#{errors.count > 1 ? \"s\" : \"\"}.\")\n elsif warnings.count > 0\n warn_message = \"SwiftLint found \"\n types = []\n types << \"#{warnings.count} warning#{warnings.count > 1 ? \"s\" : \"\"}\" if warnings.count > 0\n types << \"#{errors.count} error#{errors.count > 1 ? \"s\" : \"\"}\" if errors.count > 0\n warn_message << types.join(\" and \") << \".\"\n warn(warn_message)\n else\n message(\"SwiftLint found no issues.\")\n end\n\n\n end",
"def create_report\n dir = Dir.pwd\n file_name = \"#{@name}.log\"\n reports_dir = dir + \"/spec/reports\"\n if File.directory? reports_dir\n @spec_report_file = File.open(reports_dir + \"/\" + file_name, 'w')\n @spec_report_file.puts \"WatirmarkLog: \" + @name\n else\n #spec/Reports directory does not exits\n @spec_report_file = nil\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Check gradlew file exists in current directory.
|
def gradlew_exists?
!`ls gradlew`.strip.empty?
end
|
[
"def gradlew_exists?\n `ls gradlew`.strip.empty? == false\n end",
"def web_build_exists?\n File.exist?(File.join(absolute_path, 'package.json'))\n end",
"def test_env_sample_exists\n assert(File.file?('./.env_sample'))\n end",
"def project_configuration_file_exists?\n File.exists? project_configuration_file\n end",
"def current_folder_has_souffle_config?\n File.exists? \"#{Dir.pwd}/souffle.json\"\n end",
"def donutfile_exists?\n File.exist? \"#{Donut::CLI::ROOT}/Donutfile.rb\"\n end",
"def dir_exists?\n Dir.exists?(config_dir)\n end",
"def exist?\n File.exist?(source_path)\n end",
"def source_exist?\n @base_path && File.exist?(@base_path) ||\n @env_path && File.exist?(@env_path)\n end",
"def file_exists?(file_path)\n File.exist? @site.in_source_dir(file_path)\n end",
"def exists?\n factory.system.dir_exists?(@path)\n end",
"def working_dir_exists?\n File.directory?(WORKING_DIR) && File.exist?(WORKING_DIR)\n end",
"def fs_exist?(file)\n File.exist?(File.join(self.git_dir, file))\n end",
"def local_exists?\n File.exist? path\n end",
"def installed?\n File.exist?(swiftlint_path)\n end",
"def gradlew\n @gradlew ||= begin\n gradlew = config.dig(\"gradle\", \"gradlew\")\n config.root.join(gradlew || \"gradlew\").to_s\n end\n end",
"def config_exists?\n\t\t\tFile.exists?(config_location)\n\t\tend",
"def check_file_exist(path)\n raise \"Cannot find: #{path}\" unless File.exist?(path)\n end",
"def installed?\n File.exists?(@path)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A getter for `spotbugs_report`, returning SpotBugs report.
|
def spotbugs_report(report_file)
require 'oga'
Oga.parse_xml(File.open(report_file))
end
|
[
"def report_file\n @report_file ||= 'app/build/reports/spotbugs/release.xml'\n end",
"def get_bug_report_fields\n return bugs_report_fields\n end",
"def report\n return @report\n end",
"def getBug(response)\r\n\t\t\t\tbug_json = JSON.parse response\r\n\t\t\t\tbug_array = bug_json[\"bugs\"]\r\n\t\t\t\treturn jsonToBug(bug_array[0])\r\n\t\t\tend",
"def getBuglogs\r\n\t\t\t\t\treturn @buglogs\r\n\t\t\t\tend",
"def get_bugs(component = nil)\n return bugs if component.nil?\n\n pkg = Package.find_by_name(component)\n return Bug.where('1 = 0') unless pkg\n return bugs.where(:package_id => pkg)\n end",
"def getBugsAPI\r\n\t\t\t\t\tbugsAPI = BugsAPI.new(authToken, portalId)\t\t\r\n\t\t\t\t\treturn bugsAPI\r\n\t\t\t\tend",
"def bug_report_url()\n LibDrizzle.drizzle_bugreport\n end",
"def get_bug(id)\n get_bugs(id).first\n end",
"def get_bugs(bugs, fields = FIELDS_SUMMARY)\n params = {}\n\n params['ids'] = case bugs\n when Array\n bugs\n when Integer || String\n [bugs]\n else\n raise ArgumentError, format('Unknown type of arguments: %s', bugs.class)\n end\n\n unless fields.nil?\n unless (fields - FIELDS_ALL).empty?\n raise ArgumentError, format('Invalid fields: %s', (FIELDS_ALL - fields).join(' '))\n end\n\n params['include_fields'] = fields\n end\n\n result = get(params)\n\n if fields.nil? || fields == FIELDS_ALL\n get_comments(bugs).each do |id, c|\n result['bugs'].each do |r|\n next unless r['id'].to_s == id.to_s\n\n r['comments'] = c['comments']\n r['comments'] = [] if r['comments'].nil?\n break\n end\n end\n end\n\n # 'bugs' is only in interests.\n # XXX: need to deal with 'faults' ?\n result['bugs']\n end",
"def bugs\n bugzilla_resource('Bug')\n end",
"def bugs_report\n @project = Project.find(params[:id])\n @data = @project.get_bugs_report\n \n respond_to do |format|\n format.html #bugs_report.html.erb\n format.json \n end\n end",
"def index\n @bugs = @project.bugs\n end",
"def get_report(id)\n report = reports.detect { |r| r.id == id }\n raise(UsbException, \"No report with id #{id}\") if report.nil?\n return report\n end",
"def get_bug_tracker_url\n return @BugTrackerURL\n end",
"def reported\n @reported = Post.where(report: true)\n end",
"def _findBugs\n @metric.return_scope\n end",
"def getBugId\r\n\t\t\t\t\treturn @bugId\r\n\t\t\t\tend",
"def report\n validate\n parse\n filter_issues\n comment\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Returns +ture+ if the element is included in _self_.
|
def include?(elem)
@elements.include?(elem)
end
|
[
"def not_include?(element)\n !self.include?(element)\n end",
"def include?(el)\n end",
"def include?(item)\n true\n end",
"def include?( element_id )\n self.elements_ids.include?( element_id )\n end",
"def included?\n if self.included.nil?\n (parent.nil? ? false : parent.included?)\n else\n self.included\n end\n end",
"def include?(tree)\n return true if self == tree # Same tree, so inclusion.\n # Check the child\n return true if @child.include?(tree)\n # Do not include\n return false\n end",
"def include?(item)\n each.to_a.include?(item)\n end",
"def include?(item)\n end",
"def is_prior_to(elem)\n return nil if self == elem\n elem.higher_priority_elements << self\n self.lower_priority_elements << elem\n true\n end",
"def include?(tree)\n # By default: equality comparison.\n return self == tree\n end",
"def include? x\n ! ! _set.key?(x)\n end",
"def include?(node)\n @set.include?(node)\n end",
"def orderable? = super && element.orderable?",
"def is_element_of(element)\n p @set.include?(element)\n end",
"def include?(member)\n `self.hasOwnProperty(member)`\n end",
"def include?(element)\n @path.include?(element)\n end",
"def include?(item)\n @children.values.include?(item) || @children.values.any? { |child| child.include?(item) }\n end",
"def include?(p0) end",
"def has_elements?\n self.each_element{ |e| return true }\n return false\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Deletes the +element+ from this max heap, and maintains the heap properties. If the element is not found, return +nil+.
|
def delete(elem)
deleted = @elements.delete(elem)
build_heap unless deleted.nil?
deleted
end
|
[
"def remove()\n return if @store.empty? # do nothing\n\n swap(0, -1) # swap the first and the last (Take the bottom level's right-most item and move it to the top, to fill in the hole.)\n removed = @store.pop\n\n heap_down() if @store.length > 1 # only if there is something to heap down\n return removed.value\n end",
"def delete(element)\n synchronize do\n @queue.delete(element)\n end\n end",
"def delete\n raise 'No such element' if @size == 0\n elt = @current.value\n if @size == 1\n @current.next = nil\n @current.previous = nil\n @current = nil\n else\n @current.next.previous = @current.previous\n @current.previous.next = @current.next\n @current = @current.next\n end\n @size -= 1\n return elt\n end",
"def pop\r\n # Return nil if the list is empty\r\n if self.head.nil?\r\n return nil\r\n end\r\n self.size -= 1\r\n return delete_element(self.head).value\r\n end",
"def delete(value)\n # Find the element to delete\n index = index(value)\n not_final = index < @heap.length - 1\n # Unless it's the final leaf, replace the value to be deleted with the final leaf\n @heap[index] = @heap[-1] if not_final\n # Delete the final leaf (either what we want to delete, or a duplicate now)\n @heap.pop\n # If necessary, bubble down\n bubble_down(index) if not_final\n end",
"def remove()\n return if @store.empty?\n \n # swap last item in heap with smallest value\n swap(0, -1)\n\n # remove smallest value\n removedNode = @store.pop\n\n # maintain heap structure\n heap_down() if @store.length > 1\n \n return removedNode.value\n end",
"def delete_element(element); end",
"def del_min\n return nil if @heap.size <= 1\n min = @heap[1]\n @heap[1] = @heap.pop\n percolate_down(1)\n return min\n end",
"def dec(element)\n if (self[elem] -= 1) == 0 then\n # No more instance of the element, remove the entry.\n self.delete(elem)\n end\n end",
"def pop\n peek.tap do |result|\n last = @nodeset.pop\n unless size.zero? # Replace the root of the heap with the last element and heapify-down\n @nodeset[1] = last\n heapify_down 1\n end\n end\n end",
"def remove(element)\n if @set.include?(element)\n @set.delete(element)\n if @capacity > 0\n p \"Deleted #{element}. Capacity #{@set.length}/#{@capacity}\"\n else\n p \"Deleted #{element}.\"\n end\n else\n p \"Set does not contain #{element}.\"\n end\n end",
"def delete_top\n raise \"Empty heap\" if @bottom == 0\n ret_value = @data[0]\n @bottom -= 1\n\n if @bottom > 0\n @data[0] = @data[@bottom]\n percolate_down(0)\n end\n\n ret_value\n end",
"def delete_top\n raise \"Empty heap\" if @bottom == 0\n ret_value = @data[0]\n @bottom -= 1\n\n if @bottom > 0\n @data[0] = @data[@bottom]\n percolate_down(0)\n end\n\n ret_value\n end",
"def delete(priority)\n @heap.delete(priority)\n end",
"def del_max\n return nil if not @root\n delete(max)\n end",
"def pop\n raise 'No such element' if @elements.length == 0\n @elements.slice!(-1)\n end",
"def del_max\n return if not @root\n x = max_node(@root)\n delete(@root, x.key) if x\n end",
"def pop\r\n\t\t\t\tentry = last\r\n\t\t\t\tdelete entry\r\n\t\t\t\tentry\r\n\t\t\tend",
"def delete_element(position)\n element = @elements[position]\n case element\n when Element::InlineBlip\n return delete_inline_blip(element.blip)\n when Element\n @elements[position] = nil\n add_operation(:type => Operation::DOCUMENT_ELEMENT_DELETE, :index => position)\n else\n raise \"No element to delete at position #{position}\"\n end\n\n self\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Returns the parent index of the element at +i+.
|
def parent(i)
(i-1)/2
end
|
[
"def parent_at(i)\n @parents.keys.sort.collect {|p| [p] * @parents[p].length }.flatten[i]\n end",
"def parent(i)\n @data[parent_index(i)]\n end",
"def parent_child_index(parent) #:nodoc:\n duck = parent[:builder].instance_variable_get('@nested_child_index')\n\n child = parent[:for]\n child = child.first if child.respond_to?(:first)\n duck[child].to_i + 1\n end",
"def get_parent(idx) \n\n\t\tif idx == 0\n\t\t\treturn nil\n\t\tend\n\n\t\tparent = ((idx - 1)/2).round() # compute the parent index\n\n\t\treturn parent\n\tend",
"def index_in_parent\n parent.index(self)+1\n end",
"def parent(index)\n (index.to_f / 2).ceil - 1\n end",
"def parent_child_index(parent) #:nodoc:\n duck = parent[:builder].instance_variable_get('@nested_child_index')\n\n if duck.is_a?(Hash)\n child = parent[:for]\n child = child.first if child.respond_to?(:first)\n duck[child].to_i + 1\n else\n duck.to_i + 1\n end\n end",
"def left_child(i)\n left = (2 * i) + 1\n if left >= @size\n return -1\n else\n return left\n end\n end",
"def min_child(i)\n min_idx = child(i)\n (min_idx+1...min_idx+@dim).each do |idx|\n break if idx >= @size\n min_idx = idx if (@pq[idx] <=> @pq[min_idx]) < 0\n end\n return min_idx\n end",
"def parent_index( local_index, parent_array = parent_array( local_index ), local_parent_map = nil )\n \n parent_index = nil\n \n if parent_array\n local_parent_map ||= local_parent_map( parent_array )\n parent_index = local_parent_map[ local_index ]\n end\n \n return parent_index\n \n end",
"def position\n self.parent.children.index(self)\n end",
"def cfei_at(i)\n\n children.find { |cfei| Ruote.extract_child_id(cfei) == i }\n end",
"def hack_parent_position\n parent_struct.index(self)\n end",
"def sibling_index\n parent.children.index { |sibling| sibling.equal?(self) }\n end",
"def get_child_index\n return 0\n end",
"def sibling_index\n parent&.children&.index { |sibling| sibling.equal?(self) }\n end",
"def right_child(i)\n right = 2 * (i + 2)\n if right >= @size\n return -1\n else\n return right\n end\n end",
"def node_child_index(parent, child); node_children(parent).index(child); end",
"def each_child_index\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Heapifies the element at position +i+.
|
def heapify(i)
left = left(i)
right = right(i)
target = i
if left < @elements.size and @comparator.call(@elements[i],@elements[left]) < 0
target = left
end
if right < @elements.size and @comparator.call(@elements[target],@elements[right]) < 0
target = right
end
unless target == i
swap(target,i)
heapify(target)
end
end
|
[
"def heapify(i)\n left = left_index(i)\n left = nil if left >= @data.size\n\n right = right_index(i)\n right = nil if right >= @data.size\n\n largest = [i,left,right].compact.sort{|x,y| relation(x,y)?-1:1}.first\n\n if largest != i\n @data[i], @data[largest] = @data[largest], @data[i]\n heapify(largest)\n end\n end",
"def heapify(array, i, max_index)\n tmp = array[i]\n j = 2*i + 1\n while j <= max_index\n j += 1 if j < max_index && array[j] < array[j+1]\n break if array[j] <= tmp\n array[i] = array[j]\n i, j = j, 2*i + 1\n end\n array[i] = tmp\n end",
"def max_heapify!(i)\n l = left(i)\n r = right(i)\n\n if l < self.heapsize && self[l] > self[i]\n largest = l\n else\n largest = i\n end\n\n if r < self.heapsize && self[r] > self[largest]\n largest = r\n end\n\n if largest != i\n exchange(i, largest)\n max_heapify!(largest)\n end\n\n return self\n end",
"def heapify!\n (@data.size/2).downto(0) do |i|\n heapify(i)\n end\n end",
"def max_heapify(list, heap_size, i)\n i = i.to_i\n\n left = i * 2\n right = i * 2 + 1\n largest = i\n\n if left < heap_size && list[left] > list[i]\n largest = left\n end\n\n if right < heap_size && list[right] > list[largest]\n largest = right\n end\n\n if largest != i\n _temp = list[i]\n list[i] = list[largest]\n list[largest] = _temp\n max_heapify(list, heap_size, largest)\n end\nend",
"def n_heapify_heapsort(lam, p, i = 0)\n\t\twhile size > 0\n\t\t\tl = left_index(i)\n\t\t\tr = right_index(i)\n\t\t\ttemp = (l < p and lam.call(@heap[l],@heap[i])) ? l : i\n\t\t\ttemp = r if (r < p and lam.call(@heap[r], @heap[temp]))\n\t\t\tif temp != i\n\t\t\t\tvar = @heap[i]\n\t\t\t\t@heap[i] = @heap[temp]\n\t\t\t\t@heap[temp] = var\n\t\t\tend\n\t\t\tbreak if temp == i\n\t\t\ti = temp\n\t\t\tp -= 1\n\t\tend\n\t\t@heap\n\tend",
"def heapify(arr, n, i)\n largest = i # Initialize largest as root\n l = 2 * i + 1 # index of left child\n r = 2 * i + 2 # index of right child\n\n # Check if left child of root exists and is greater than root\n if l < n && arr[i] < arr[l]\n largest = l\n end\n\n # Check if right child of root exists and is greater than root\n if r < n && arr[largest] < arr[r]\n largest = r\n end\n\n # Change root if needed\n if largest != i\n swap(arr, i, largest) # swap\n heapify(arr, n, largest)\n end\nend",
"def build_heap\n (@heap_size/2 - 1).downto(0) do |i|\n heapfiy(i)\n i -= 1\n end\n end",
"def insert(element)\n @heap << element\n heapify_up\n p @heap\n end",
"def sift_up(i)\n parent = (i - 1) / 2\n if parent >= 0 and @heap[parent] > @heap[i]\n @heap[parent], @heap[i] = @heap[i], @heap[parent]\n sift_up(parent)\n end\n end",
"def build_minheap\n\t\ti = @heap.length/2\n\t\twhile i >= 0\n\t\t\tminheapify(i)\n\t\t\ti -= 1\n\t\tend\n\tend",
"def build_heap\n @heap_size = length\n (length / 2).floor.downto(1) do |i| \n heapify_downward i \n end\n end",
"def unheapify!(array)\n array.each_index do |current|\n heap_length = array.length - 1 - current\n\n # Starts building the array at the end of the heap\n swap!(array, 0, heap_length)\n\n # Accounts for shortening of heap due to array construction at the end\n current -= (array.length - heap_length - 1)\n\n # Swaps the current node with its best(smallest) child if it's\n # bigger than its children\n while heapify_down?(array, current, heap_length)\n best_child = children(current, heap_length).min_by do |child_idx|\n array[child_idx]\n end\n\n swap!(array, current, best_child)\n\n # Reset current to child to keep swapping down if needed.\n current = best_child\n end\n end\nend",
"def sink(i)\n return if child(i) >= @size\n min_idx = min_child(i)\n while min_idx < @size and (@pq[i] <=> @pq[min_idx]) > 0\n @pq[i], @pq[min_idx] = @pq[min_idx], @pq[i]\n i, min_idx = min_idx, min_child(min_idx)\n end\n end",
"def heapify ary\n ((ary.length - 2) / 2).downto(0) { |start_idx| ary = sift_down ary, start_idx, ary.length - 1 }\n ary\nend",
"def heapify(**val)\n val.each do |k, v|\n insert(k, v)\n end\n val.length\n end",
"def max_heap_insert(arr, key)\n arr.heap_size ||= arr.length\n arr.heap_size += 1\n arr[arr.heap_size-1] = -Float::INFINITY\n heap_increase_key(arr, arr.heap_size-1, key)\n end",
"def build_heap(array)\n heap_size = array.length\n i = (heap_size/2).to_i\n while i >= 0\n max_heapify(array, heap_size, i)\n i -= 1\n end\n array\nend",
"def heap_increase_key(arr, i, key)\n raise 'new key is smaller than current key' if key < arr[i]\n arr[i] = key\n while i > 0 && arr[i.parent] < arr[i]\n arr[i], arr[i.parent] = arr[i.parent], arr[i]\n i = i.parent\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Checks if this numeric range intersects with another
|
def intersect?(o)
self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
end
|
[
"def bounds_intersected_by?(range)\n return false if IntervalSet.range_empty?(range)\n\n !empty? && range.first < max && range.last > min\n end",
"def bounds_intersected_or_touched_by?(range)\n return false if IntervalSet.range_empty?(range)\n\n !empty? && range.first <= max && range.last >= min\n end",
"def in_range?\n return self.range.include?([@x, @y])\n end",
"def intersect?(range)\n return false if range.nil?\n\n (@lower <= range.lower && @upper > range.lower) ||\n (@lower < range.upper && @upper >= range.upper) ||\n (range.lower <= @lower && range.upper > @lower) ||\n (range.lower < @upper && range.upper >= @upper)\n end",
"def range_overlaps?(rng1, rng2)\n rng2.first >= rng1.first && rng2.last <= rng1.last\n end",
"def covers?(*args)\n other = coerce_range(*args)\n\n if other.instant?\n self.begin <= other.begin and other.end < self.end\n else\n self.begin <= other.begin and other.end <= self.end\n end\n end",
"def include_range? other_range\n case other_range\n when Range\n if other_range.first >= self.first && other_range.last <= self.last\n return true\n else\n return false\n end\n else\n raise \"unsupported type\"\n end\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 vt_intersects?(*args)\n vt_range.intersects?(*args)\n end",
"def fully_overlapped_by?(range1, range2)\n range2.first <= range1.first && range1.last <= range2.last\n end",
"def overlaps?(range)\n !(completely_left_of?(range) || completely_right_of?(range))\n end",
"def tt_intersects?(*args)\n tt_range.intersects?(*args)\n end",
"def ==(other)\r\n @range == other.range\r\n end",
"def within_range?\n lng_range.include?(coordinates.lng) && lat_range.include?(coordinates.lat)\n end",
"def overlaps? other\n postgis_calculate(:overlaps, [self, other])\n end",
"def included_in?(other_rect)\n self == self.intersects(other_rect)\n end",
"def ==(other)\n return false unless Range === other \n return self.first == other.first && self.last == other.last && self.exclude_end? == other.exclude_end?\n end",
"def left_overlapped_by?(other)\n (x_start..x_end).cover?(other.x_end)\n end",
"def ==(range)\n @lower == range.lower && @upper == range.upper\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /event_elements GET /event_elements.json
|
def index
@event_elements = EventElement.all
end
|
[
"def get_events\n Resources::Event.parse(request(:get, \"Events\"))\n end",
"def events\n response = self.class.get('/v1/events.json')\n response.code == 200 ? JSON.parse(response.body) : nil\n end",
"def events\n events = @vulnerability.events.map do |e|\n {\n id: e.id,\n title: e.title,\n description: e.description,\n date: e.date,\n event_type: e.event_type,\n color: e.color,\n icon: e.icon,\n notes: e.notes,\n start_hidden: e.start_hidden,\n }\n end\n render_json_for_api events\n end",
"def adverse_events\n get_data_elements('adverse_event')\n end",
"def events\n data[\"events\"]\n end",
"def get_events()\n @client.make_request(:get, @client.concat_user_path(\"#{CALL_PATH}/#{id}/events\"))[0]\n end",
"def get_event_list ( year )\n get_api_resource \"#{@@api_base_url}events/#{year}\"\n end",
"def getevents\n start_time = Time.at(params[:start].to_i)\n end_time = Time.at(params[:end].to_i)\n events = []\n TimeBlock.where(:starttime => (start_time...end_time)).each do |t|\n e = t.event\n events << {:id => e.id, :description => e.description, :title => e.title, :allDay => false, :start => t.starttime, :end => t.endtime, :resource => e.id.to_s}\n end\n render :json => events\n\n end",
"def index\n @event_users = Event.find_by(id:request.headers['EventId'].to_s).event_users\n\n render json: @event_users\n end",
"def get_events(size = 30, page = 1)\n response = make_request('/api/v1/applications/me/events?per=' + size.to_s + '&page=' + page.to_s, 'GET')\n begin\n data = JSON.parse(response)\n list = []\n data.each do |j|\n list.push(FomoEvent.new(j['id'], j['created_at'], j['updated_at'], j['message'], j['link'], j['event_type_id'], j['event_type_tag'], j['url'], j['first_name'], j['email_address'], j['ip_address'], j['city'], j['province'], j['country'], j['title'], j['image_url'], j['custom_event_fields_attributes']))\n end\n list\n rescue JSON::ParserError => _\n # String was not valid\n end\n end",
"def get_events\n response = request(:get, \"/devmgr/v2/events\")\n #status(response, 200, 'Failed to get current events from server')\n #JSON.parse(response.body)\n response\n end",
"def all(options = nil)\n request = Request.new(@client)\n path = \"/events\"\n data = {\n\n }\n\n response = Response.new(request.get(path, data, options))\n return_values = Array.new\n \n a = Array.new\n body = response.body\n for v in body['events']\n tmp = Event(@client)\n tmp.fill_with_data(v)\n a.push(tmp)\n end\n\n return_values.push(a)\n \n\n \n return_values[0]\n end",
"def all(params = {})\n req = WebPay::EventListRequest.create(params)\n raw_response = @client._request(:get, 'events', req)\n WebPay::EventResponseList.new(raw_response)\n end",
"def index\n @elements = Element.all\n render json: @elements\n end",
"def get_events(args)\n\t\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\t\t\tdo_the_get_call( url: api_url )\n\t\tend",
"def events(method, params)\n # can't do this without an auth_key...\n raise 'Authentication Key required.' if @auth_key.nil?\n \n events = request(method, params)\n return EventList.new(events['eventList']) if events['eventList']\n \n nil # fall through return...\n end",
"def event\n begin\n JSON.parse(@omegle.post('/events', \"id=#{@id}\").body)\n rescue\n end\n end",
"def index\n @elements = Element.all\n\n render json: @elements\n end",
"def index\n @client_events = ClientEvent.all\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /event_elements POST /event_elements.json
|
def create
@event_element = EventElement.new(event_element_params)
respond_to do |format|
if @event_element.save
format.html { redirect_to @event_element, notice: 'Event element was successfully created.' }
format.json { render :show, status: :created, location: @event_element }
else
format.html { render :new }
format.json { render json: @event_element.errors, status: :unprocessable_entity }
end
end
end
|
[
"def push_events\n saved = []\n jsonHash = request.POST[:_json];\n jsonHash.each do |jsonEvent|\n event = Event.new\n event.race_id = jsonEvent[\"raceId\"]\n event.walker_id = jsonEvent[\"walkerId\"]\n event.eventId = jsonEvent[\"eventId\"]\n event.eventType = jsonEvent[\"type\"]\n event.eventData = jsonEvent[\"data\"]\n event.batteryLevel = jsonEvent[\"batL\"]\n event.batteryState = jsonEvent[\"batS\"]\n event.timestamp = Time.zone.parse(jsonEvent[\"time\"])\n if event.save # if new\n saved << jsonEvent[\"eventId\"]\n if event.race_id != 0 # if not unknown race_id\n after_create(event)\n end\n else # if exists\n saved << jsonEvent[\"eventId\"]\n puts \"Not Saved!\" # debug print\n puts jsonEvent # debug print \n end\n end\n render :json => {:savedEventIds => saved}\n end",
"def send_events(event_list)\n @wire_client.post_data(event_list)\n end",
"def create\n @event = Event.new(event_params)\n if @event.save\n render json: @event.to_json, status: :created\n else\n render json: @event.errors, status: :unprocessable_entity\n end\n end",
"def event\n begin\n JSON.parse(@omegle.post('/events', \"id=#{@id}\").body)\n rescue\n end\n end",
"def index\n @event_elements = EventElement.all\n end",
"def create\n @recurring_event = RecurringEvent.new(recurring_event_params)\n\n respond_to do |format|\n if @recurring_event.save\n @recurring_event.schedule_recurring_events.each do |event|\n @recurring_event.events << Event.new(title: @recurring_event.title,\n color: @recurring_event.color, recurring_event: @recurring_event,\n turma_id: params[:outros][:turma_id],\n discipline_id: params[:outros][:discipline_id],\n start_date: formatar_data_evento(event, @recurring_event.start_date),\n end_date: formatar_data_evento(event, @recurring_event.end_date)\n )\n end\n format.html { redirect_to @recurring_event, notice: 'Recurring event was successfully created.' }\n format.json { render :show, status: :created, location: @recurring_event }\n else\n format.html { render :new }\n format.json { render json: @recurring_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def save\n event = params\n # This assumes that all keys exists. Yay no error handling...\n toSave = Event.new(update_type: event[:event],\n start_time: event[:payload][:event][:start_time_pretty],\n end_time: event[:payload][:event][:end_time_pretty],\n location: event[:payload][:event][:location],\n invitee_name: event[:payload][:invitee][:name],\n duration: event[:payload][:event_type][:duration],\n event_kind: event[:payload][:event_type][:kind])\n toSave.save\n render json: {}, status: 200\n end",
"def post_event(url, event, payload_type, payload)\n body = {\n :event => event,\n :payload_type => payload_type }\n body[:payload] = payload if payload\n\n http_post(url) do |req|\n req.headers['Content-Type'] = 'application/json'\n req.body = body.to_json\n req.params['verification'] = 1 if event == 'verification'\n end\n end",
"def create\n event = Event.create(event_params)\n if event.save\n render json: event, status: 200\n else\n render json: {errors: event.errors.full_messages}, status: :unprocessable_entity\n end\n end",
"def submit\n if (session[:user_id] != nil)\n # https://stackoverflow.com/a/13606990\n \n event_params()[:date] = Date.new(\n params[:event][\"date(1i)\"].to_i,\n params[:event][\"date(2i)\"].to_i,\n params[:event][\"date(3i)\"].to_i\n )\n \n event = Event.new(event_params())\n \n event.attending_count = 0\n \n # Check if the validations are successful and return false if they're not\n # If validations fail, abort and do not save\n # http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-save\n if event.save\n redirect_to events_path\n else\n # If there are any errors, set the flash warning to include the array of error messages\n if event.errors.any?\n flash[:warning] = event.errors.full_messages.uniq\n \n redirect_to events_create_path\n end\n end\n else\n redirect_to login_path\n end\n end",
"def create\n @event = Event.find(params[:event_id])\n @event_entry = @event.event_entries.build(params[:event_entry])\n\n respond_to do |format|\n if @event_entry.save\n format.html { redirect_to @event, :notice => 'Event entry was successfully created.' }\n format.json { render :json => @event, :status => :created, :location => @event_entry }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @event_entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def events\n events = @vulnerability.events.map do |e|\n {\n id: e.id,\n title: e.title,\n description: e.description,\n date: e.date,\n event_type: e.event_type,\n color: e.color,\n icon: e.icon,\n notes: e.notes,\n start_hidden: e.start_hidden,\n }\n end\n render_json_for_api events\n end",
"def create\n @element = Element.new(element_params)\n\n if @element.save\n render json: @element, status: :created\n else\n render json: @element.errors, status: :unprocessable_entity\n end\n end",
"def create\n Rails.logger.debug(\"Received event #{params[:event]}\")\n head :ok\n end",
"def publish_batch(events)\n ensure_project_id!\n ensure_write_key!\n publish_body(\n api_events_resource_path,\n MultiJson.encode(events),\n \"publish\")\n end",
"def create\n itinerary = current_user.itineraries.create!(itinerary_params)\n itinerary_id = current_user.itineraries.last\n \n events = params[:events]\n events.each do |event|\n itinerary_id = current_user.itineraries.last[:id]\n EventsItinerary.create(itinerary_id: itinerary_id, event_id: event[\"id\"])\n end\n render json: itinerary, status: 201 # , location: [:api, itineraries]\n end",
"def addDates()\n\tdates = JSON.parse(params[:dates_array])\n\tfor day in dates do \n\t\t@event.days.push(Day.create(:event_id => @event.id, :cal_day => Date.strptime(day, \"%m/%d/%Y\")))\n\tend\nend",
"def create\n params.delete(:activated)\n params.delete(:seen)\n params.delete(:object_id)\n params.delete(:object_type)\n @holocene_event = HoloceneEvent.new(holocene_event_params)\n\n respond_to do |format|\n if @holocene_event.save\n format.html { redirect_to @holocene_event, notice: 'Holocene event was successfully created.' }\n format.json { render :show, status: :created, location: @holocene_event }\n else\n format.html { render :new }\n format.json { render json: @holocene_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @js_event = JsEvent.new(params[:js_event])\n\n respond_to do |format|\n if @js_event.save\n format.html { redirect_to @js_event, notice: 'Js event was successfully created.' }\n format.json { render json: @js_event, status: :created, location: @js_event }\n else\n format.html { render action: \"new\" }\n format.json { render json: @js_event.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PATCH/PUT /event_elements/1 PATCH/PUT /event_elements/1.json
|
def update
respond_to do |format|
if @event_element.update(event_element_params)
format.html { redirect_to @event_element, notice: 'Event element was successfully updated.' }
format.json { render :show, status: :ok, location: @event_element }
else
format.html { render :edit }
format.json { render json: @event_element.errors, status: :unprocessable_entity }
end
end
end
|
[
"def update\n event = event.find(params[\"id\"]) \n event.update_attributes(event_params) \n respond_with event, json: event\n end",
"def update\n #TODO params -> strong_params\n if @event.update(params)\n head :no_content\n else\n render json: @event.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @event.update(event_params)\n format.json { head :no_content }\n else\n format.json { render json: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event_req = EventReq.find(params[:id])\n\n respond_to do |format|\n if @event_req.update_attributes(params[:event_req])\n format.html { redirect_to @event_req, notice: 'Event req was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @event_req.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event_document = EventDocument.find(params[:id])\n\n respond_to do |format|\n if @event_document.update_attributes(params[:event_document])\n @event_document.event.touch\n format.html { redirect_to @event_document, notice: 'Event document was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @event_document.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @simple_event = SimpleEvent.find(params[:id])\n\n respond_to do |format|\n if @simple_event.update_attributes(params[:simple_event])\n format.html { redirect_to @simple_event, notice: 'Simple event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\", :layout => 'dashboard' }\n format.json { render json: @simple_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @js_event = JsEvent.find(params[:id])\n\n respond_to do |format|\n if @js_event.update_attributes(params[:js_event])\n format.html { redirect_to @js_event, notice: 'Js event was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @js_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n get_event\n @event_prerequisite = @event.prerequisites.find(params[:id])\n @event_prerequisite.update_attributes(params[:event_prerequisite])\n\n respond_to do |format|\n format.json { respond_with_bip(@event_prerequisite) }\n end\n end",
"def update\n @important_event = ImportantEvent.find(params[:id])\n\n respond_to do |format|\n if @important_event.update_attributes(params[:important_event])\n format.html { redirect_to @important_event, notice: 'Important event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @important_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @base_event.update(base_event_params)\n format.json { head :no_content }\n else\n format.json { render json: @base_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_event(event)\n response = make_request('/api/v1/applications/me/events/' + event.id.to_s, 'PATCH', event)\n begin\n j = JSON.parse(response)\n FomoEvent.new(j['id'], j['created_at'], j['updated_at'], j['message'], j['link'], j['event_type_id'], j['event_type_tag'], j['url'], j['first_name'], j['email_address'], j['ip_address'], j['city'], j['province'], j['country'], j['title'], j['image_url'], j['custom_event_fields_attributes'])\n rescue JSON::ParserError => _\n # String was not valid\n end\n end",
"def update\n @event_request = EventRequest.find(params[:id])\n\n respond_to do |format|\n if @event_request.update_attributes(params[:event_request])\n format.html { redirect_to @event_request, notice: 'Event request was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @event_request.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @axis_event.update(axis_event_params)\n format.html { redirect_to @axis_event, notice: 'Axis event was successfully updated.' }\n format.json { render :show, status: :ok, location: @axis_event }\n else\n format.html { render :edit }\n format.json { render json: @axis_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event = Event.from_param(params[:event_id])\n @time_table = @event.time_tables.where(:permalink => params[:id]).first\n success = params[:time_table] && params[:time_table][:times] && \n @time_table.update_attributes(:times => JSON.parse(params[:time_table][:times]))\n success ? update_success : update_failure\n rescue JSON::ParserError\n update_failure\n end",
"def update_rest\n @page_usage_event = PageUsageEvent.find(params[:id])\n\n respond_to do |format|\n if @page_usage_event.update_attributes(params[:page_usage_event])\n flash[:notice] = 'PageUsageEvent was successfully updated.'\n format.html { redirect_to(@page_usage_event) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page_usage_event.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @everyday_event.update(everyday_event_params)\n format.html { redirect_to @everyday_event, notice: 'Everyday event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @everyday_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @item_event = ItemEvent.find(params[:id])\n\n respond_to do |format|\n if @item_event.update_attributes(params[:item_event])\n format.html { redirect_to @item_event, notice: 'Item event was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @item_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @ticketing_event = Ticketing::Event.find(params[:id])\n\n respond_to do |format|\n if @ticketing_event.update_attributes(params[:ticketing_event])\n format.html { redirect_to ticketing_events_path }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @ticketing_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event_requirement = EventRequirement.find(params[:id])\n\n if @event_requirement.update(event_requirement_params)\n head :no_content\n else\n render json: @event_requirement.errors, status: :unprocessable_entity\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /event_elements/1 DELETE /event_elements/1.json
|
def destroy
@event_element.destroy
respond_to do |format|
format.html { redirect_to event_elements_url, notice: 'Event element was successfully destroyed.' }
format.json { head :no_content }
end
end
|
[
"def destroy\n @simple_event = SimpleEvent.find(params[:id])\n @simple_event.destroy\n\n respond_to do |format|\n format.html { redirect_to simple_events_dashboard_index_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @event = Event.using(:shard_one).find(params[:id])\n @event.destroy\n\n respond_to do |format|\n format.html { redirect_to events_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @event.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def delete_events(args)\n\t\t\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\t\t\tdo_the_delete_call( url: api_url )\n\t\tend",
"def remove_one_event(event)\n client.execute(\n :api_method => calendar.events.delete,\n :parameters => {:calendarId => calendar_id, :eventId => event['id']})\n end",
"def destroy\n @event_document = EventDocument.find(params[:id])\n @event_document.event.touch\n @event_document.destroy\n\n respond_to do |format|\n format.html { redirect_to event_documents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @event_req = EventReq.find(params[:id])\n @event_req.destroy\n\n respond_to do |format|\n format.html { redirect_to event_reqs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @eventtype.events.each do |e|\n e.destroy\n end\n @eventtype.destroy\n respond_to do |format|\n format.html { redirect_to eventtypes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @important_event = ImportantEvent.find(params[:id])\n @important_event.destroy\n\n respond_to do |format|\n format.html { redirect_to important_events_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @event_request.destroy\n head :no_content\n end",
"def delete_event(event)\n notifications = \"sendNotifications=#{event.send_notifications?}\"\n send_events_request(\"/#{event.id}?#{notifications}\", :delete)\n end",
"def destroy\n @js_event = JsEvent.find(params[:id])\n @js_event.destroy\n\n respond_to do |format|\n format.html { redirect_to js_events_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @myevent = Myevent.find(params[:id])\n @myevent.destroy\n\n respond_to do |format|\n format.html { redirect_to myevents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n event_type = EventType.find(params[:id])\n event_type.destroy\n head 204\n end",
"def destroy\n @everyday_event.destroy\n respond_to do |format|\n format.html { redirect_to everyday_events_url }\n format.json { head :no_content }\n end\n end",
"def delete_event(event)\n @connection.send(Addressable::URI.parse(events_url + \"/#{event.id}\"), :delete)\n end",
"def destroy\n @authevent.destroy\n respond_to do |format|\n format.html { redirect_to authevents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @add_event = AddEvent.find(params[:id])\n @add_event.destroy\n\n respond_to do |format|\n format.html { redirect_to add_events_url }\n format.json { head :no_content }\n end\n end",
"def delete_event\r\n event = Event.find_by(id: params[:eventid].to_i)\r\n if event.present?\r\n event.update(status: 3)\r\n lt_update_event_status event, 'archived'\r\n render json: SuccessResponse.new(\r\n code: 200,\r\n message: 'Event Deleted.'\r\n ), adapter: :json, status: :ok\r\n else\r\n render json: ErrorResponse.new(\r\n code: 404,\r\n message: 'Event not found!'\r\n ), adapter: :json, status: :not_found\r\n end\r\n\r\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
up by identifiers for each block, print 1 message per failure or error found
|
def parse_message_from_log_entry
unique_messages = { }
id = ""
ARGF.each do |line|
block_id = line.match(/Loaded suite (.*)/)
failure_msg = line.match(/[1-9]+ failures/)
err_msg = line.match(/[1-9]+ errors/)
if ! block_id.nil?
id = block_id[1]
elsif ! failure_msg.nil?
unique_messages["FAIL: #{id}"] = ""
elsif ! err_msg.nil?
unique_messages["ERROR: #{id}"] = ""
end
end
puts unique_messages.keys.join("\n")
end
|
[
"def print_failures\n report_errors.each { | err| puts \" + #{err}\" }\n errors.each { |err| puts \" - #{err}\" }\n end",
"def summarize_errors\n return if failures_and_errors.empty?\n\n puts \"Failures:\"\n puts\n\n pad_indexes = failures_and_errors.size.to_s.size\n failures_and_errors.each_with_index do |error, index|\n if ErroredTest === error\n colorize_as = :errored\n error_prefix = \"With #{error.error.class.name}:\"\n else\n colorize_as = :failed\n error_prefix = \"With\"\n end\n\n lines = []\n lines << \" #{pad(index+1, pad_indexes)}) #{test_type(error)}: `#{error.test_name}' (on line #{error.line} of `#{error.file}')\"\n lines.concat indent(\"#{error_prefix} `#{error.error_message}'\", 6 + pad_indexes)\n lines.concat indent(error.backtrace, 6 + pad_indexes)\n lines.each { |line| puts line, colorize_as }\n puts\n end\n end",
"def setup_fail(message)\n puts '-'*50\n message.each { |line| puts line }\n puts '-'*50\n exit\n end",
"def failures_summary\n return if @fast_fail\n\n failed_tests.each do |test|\n print_failure(test)\n end\n end",
"def dump_failure(counter, failure)\n end",
"def print_errors(rows)\n print \"Errors:\\n\"\n rows.each do |row|\n print \"Row #{row[:row_number]} rejected: #{row[:validation_errors].join(\", \")}\\n\"\n\n end\n print \"\\n\"\n end",
"def check_for_errors\n return unless @chunks.any? { |chunk| chunk.first[0] == :error }\n errors = @chunks.find_all { |chunk| chunk[0] == :error }\n $stderr.puts \"WARNING: found the following errors: #{errors.map(&last).inspect}\"\n end",
"def print_invalid_users\n puts \"==================================================\"\n puts \"============ Malformed User Records ==============\"\n puts \"==================================================\"\n\n @bad_user_records.each do |rec|\n rec.output\n puts \"\"\n end\n end",
"def each_failed_record(&block)\n each('state' => 'failed') do |slice|\n if slice.exception && (record_number = slice.exception.record_number)\n block.call(slice.at(record_number - 1), slice)\n end\n end\n end",
"def verify_transaction_data\n\n @blocks.each do |block|\n\n block_transactions = block.transactions\n block_users = []\n\n # Loop through each transaction\n block_transactions.split(\":\").each do |transaction|\n\n from = t_from(transaction)\n to = t_to(transaction)\n amt = t_amt(transaction).to_i\n\n if from.length > 6 || from.length < 1\n puts \"Line #{block.number}: Invalid block, address #{from} is not > 6 alphabetic characters.\"\n return false\n end\n\n if to.length > 6 || to.length < 1\n puts \"Line #{block.number}: Invalid block, address #{to} is not > 6 alphabetic characters.\"\n return false\n end\n\n # If it's from the system, ignore adding SYSTEM to the @user_list or decreasing coins\n if(from != \"SYSTEM\")\n\n if !@user_list.user_exist?(from)\n from = @user_list.add_user(from, 0)\n else\n from = @user_list.find_user(from)\n end\n\n from.num_coins -= amt\n\n block_users << from\n\n end\n\n if !@user_list.user_exist?(to)\n to = @user_list.add_user(to, 0)\n else\n to = @user_list.find_user(to)\n end\n\n to.num_coins += amt\n\n block_users << to\n\n end\n\n # Check the users in this block for a negative balance\n block_users.each do |user|\n\n if user.negative_balance?\n puts \"Line #{block.number}: Invalid block, address #{user.name} has #{user.num_coins} billcoins!\"\n return false\n end\n\n end\n\n end\n\n end",
"def send_hashes(event)\n levels = MappackLevel.where('mappack_id > 0')\n count = levels.count\n res = levels.each_with_index.select{ |l, i|\n dbg(\"Hashing level #{i} / #{count}...\", newline: false, pad: true)\n !l.compare_hashes\n }.map{ |map, i| map.name }\n event << \"There are #{res.size} levels with differing hashes:\"\n res.size <= 20 ? event << format_block(res.join(\"\\n\")) : send_file(event, res.join(\"\\n\"))\nrescue => e\n lex(e, \"Error getting hash discrepancies.\", event: event)\nend",
"def failure_details(io)\n super\n unless test_case.input.empty?\n format_block(io, \"Input\", test_case.input)\n end\n format_block(io, \"Evaluated commands\", test_case.evaluated_commands)\n comparisons.each do |expectation|\n expectation.format_details(io)\n end\n unless test_case.scope.debug.empty?\n format_block(io, \"Contents of *debug*\", test_case.scope.debug)\n end\n format_block(io, \"How to run this test\", test_case.shell_command_details)\n end",
"def check_and_log_error(results,output_folder,uuid,failed_output_folder, aid)\n if results['completed_status'] == \"Fail\"\n FileUtils.mkdir_p(failed_output_folder) # create failed_output_folder\n log_k, log_f = get_log_file(\"a9814f91-69e0-4e19-b55d-a68fadd7d17c\", uuid, failed_output_folder)\n # log_k => Boolean which determines if the log file has been downloaded successfully\n # log_f => path of the downloaded log file\n\n #create the csv file if it does not exist\n # this csv file will contain the building information with the eplusout.err log and the sdp_error log\n File.open(\"#{output_folder}/failed_run_error_log.csv\", 'w'){|f| f.write(\"\") } unless File.exists?(\"#{output_folder}/FAIL.log.csv\")\n\n # output the errors to the csv file\n CSV.open(\"#{output_folder}/failed_run_error_log.csv\", 'a') do |f|\n results['steps'].each do |measure|\n next unless measure[\"name\"] == \"btap_create_necb_prototype_building\"\n out = {}\n eplus = \"\" # stores the eplusout error file\n\n # check if the eplusout.err file was generated by the run\n if results.has_key?('eplusout_err')\n eplus = results['eplusout_err']\n # if eplusout.err file has a fatal error, only store the error,\n # if not entire file will be stored\n match = eplus.to_s.match(/\\*\\* Fatal \\*\\*.+/)\n eplus = match unless match.nil?\n else\n eplus = \"EPlusout.err file not generated by osw\"\n end\n\n log_content = \"\"\n # ckeck if the log file has been downloaded successfully.\n # if the log file has been downloaded successfully, then match the last ERROR\n if log_k\n log_file = File.read(log_f)\n log_match = log_file.scan(/((\\[.{12,18}ERROR\\]).+?)(?=\\[.{12,23}\\])/m)\n #puts \"log_match #{log_match}\\n\\n\".cyan\n log_content = log_match.last unless log_match.nil?\n #puts \"log_match #{log_match}\\n\\n\".cyan\n else\n log_content = \"No Error log Found\"\n end\n\n # write building_type, climate_zone, epw_file, template, uuid, eplusout.err\n # and error log content to the comma delimited file\n out = %W{#{measure['arguments']['building_type']} #{measure['arguments']['climate_zone']} #{measure['arguments']['epw_file']} #{measure['arguments']['template']} #{uuid} #{eplus} #{log_content}}\n # make the write process thread safe by locking the file while the file is written\n f.flock(File::LOCK_EX)\n f.puts out\n f.flock(File::LOCK_UN)\n end\n end #File.open(\"#{output_folder}/FAIL.log\", 'a')\n end #results['completed_status'] == \"Fail\"\nend",
"def code_problem_areas_summary\n return unless big_problems?\n\n failure_bits = {}\n\n failed_tests.each do |test|\n failure_file = test.failure.location.gsub(Dir.pwd, '').gsub('/test/', '')\n failure_message = test.failure.message\n\n if failure_bits.has_key? failure_file\n failure_bits[failure_file][:count] += 1\n else\n failure_bits[failure_file] = {\n count: 1,\n message: failure_message\n }\n end\n end\n\n failure_bits.reject! { |location, value| value[:count] == 1 }\n\n if failure_bits.any?\n problem_files = failure_bits\n .sort_by { |location, value| location }\n .reverse\n .sort_by { |location, value| value[:count] }\n .reverse\n .take(3)\n\n\n puts error('Problematic Lines of Code:')\n problem_files.each do |path, value|\n print white(value[:count].to_s + \" \")\n puts gray(path)\n puts dark_gray(\"#{value[:message]}\")\n puts\n end\n end\n end",
"def display_failures\n if @master.failures.length == 0\n chat \"All tests pass!\"\n else\n rev = `cd working-directory && git rev-parse HEAD`.chomp\n nice_output = @master.failures.map do |fail|\n \"#{fail[:header]} FAILED.\\nLocation: #{fail[:location]}\\n\\n\"\n end.join \"\"\n nice_output = \"On revision #{rev}:\\n\\n\" + nice_output\n chat \"#{nice_output}\"\n end\n end",
"def report_test_results(test_name, results)\n status = true\n message = \"\"\n for result in results\n # print (\"Status: \"+result[0].to_s+\"\\n\")\n status = (status && result[0])\n if (result[1].is_a?(Array))\n for m in result[1]\n message += m.to_s + \"\\n\\t\"\n end\n else\n message += result[1] + \"; \"\n end\n end\n\n report_test_result(test_name, status, message)\nend",
"def check_puppet_output(output)\n output.each do |o|\n if o =~ /^\\s+Failed: (\\d+)/\n raise \"Puppet failed due to #{$1} failed resource(s)\" unless $1 == \"0\"\n end\n\n if o =~ /^\\s+Skipped: (\\d+)/\n raise \"Puppet failed due to #{$1} skipped resource(s)\" unless $1 == \"0\"\n end\n end\n end",
"def dump_failure(counter, failure)\n @output << \"\\n\"\n @output << counter.to_s << \")\\n\"\n @output << \"#{failure.header}\\n\"\n @output << \"#{failure.message}\\n\"\n @output << \"#{failure.backtrace}\\n\"\n @output.flush\n end",
"def list_failures\n # ensure we don't have duplicate errors from the same repo\n remove_dups\n puts \"\\n\" unless @cmd[:show_errors]\n print_log \"\\n!! Note : The following #{@metrics[:failed_list].count}\",\n ' repositories ', 'FAILED'.red.underline, ' during this run :'\n # print out any and all errors into a nice list\n @metrics[:failed_list].each do |failed|\n print_log \"\\n [\", 'x'.red, \"] #{failed[:loc]}\"\n print_log \"\\n -> \", failed[:line].chomp.red\n end\n print_log \" \\n\\n\"\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /contacters/new GET /contacters/new.json
|
def new
@contacter = Contacter.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @contacter }
end
end
|
[
"def new\n @character = Character.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @character }\n end\n end",
"def new\n @caracteristica = Caracteristica.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @caracteristica }\n end\n end",
"def new\n @collected_character = CollectedCharacter.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @collected_character }\n end\n end",
"def new\n @char = Char.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @char }\n end\n end",
"def new\n @critic = Critic.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @critic }\n end\n end",
"def new\n add_breadcrumb I18n.t(\"char.plural\"), :chars_path\n\n @char = Char.new\n @parents_select = Char.all - [@char]\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @char }\n end\n end",
"def new\n @charmap = Charmap.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @charmap }\n end\n end",
"def new\n @cargo = Cargo.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @cargo }\n end\n end",
"def new\n @charla = Charla.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @charla }\n end\n end",
"def new\n @contacter = Contacter.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @contacter }\n end\n end",
"def new\n @contig = Contig.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @contig }\n end\n end",
"def new\n @charater = Charater.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @charater }\n end\n end",
"def new\n @crust = Crust.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @crust }\n end\n end",
"def new\n @cita = Cita.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @cita }\n end\n end",
"def new\n @fundamental_character = Fundamental::Character.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @fundamental_character }\n end\n end",
"def new\n @new_recipe = NewRecipe.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @new_recipe }\n end\n end",
"def new\n @character = Character.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @character }\n end\n end",
"def new\n @constitution = Constitution.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @constitution }\n end\n end",
"def new\n @physic = Physic.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @physic }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PUT /contacters/1 PUT /contacters/1.json
|
def update
@contacter = Contacter.find(params[:id])
respond_to do |format|
if @contacter.update_attributes(params[:contacter])
format.html { redirect_to @contacter, notice: 'Contacter was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @contacter.errors, status: :unprocessable_entity }
end
end
end
|
[
"def update\n respond_to do |format|\n if @caracter.update(caracter_params)\n format.html { redirect_to @caracter, notice: 'Caracter was successfully updated.' }\n format.json { render :show, status: :ok, location: @caracter }\n else\n format.html { render :edit }\n format.json { render json: @caracter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @character.update(character_params)\n render json: @character, status: 201, location: @character\n else\n render json: @character.errors, status: :unprocessable_entity\n end\n end",
"def update\n @character = Character.find(params[:id])\n\n respond_to do |format|\n if @character.update_attributes(params[:character])\n format.html { redirect_to @character, notice: 'Character was successfully updated.' }\n #format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n #format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @caracteristica = Caracteristica.find(params[:id])\n\n respond_to do |format|\n if @caracteristica.update_attributes(params[:caracteristica])\n format.html { redirect_to @caracteristica, notice: 'Caracteristica was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @caracteristica.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @characteristic = Characteristic.find(params[:id])\n\n respond_to do |format|\n if @characteristic.update_attributes(params[:characteristic])\n format.html { redirect_to @characteristic }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @characteristic.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character = Character.find_or_initialize_by_id(params[:id])\n @character.id = params[:id] # mass-assignment protection\n respond_to do |format|\n if @character.update_attributes(params[:character])\n format.html { redirect_to edit_character_url(@character), notice: 'Character was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @characteristic = Characteristic.find(params[:id])\n\n respond_to do |format|\n if @characteristic.update_attributes(params[:characteristic])\n format.html { redirect_to @characteristic, notice: 'Characteristic was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @characteristic.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @got_character.update(got_character_params)\n format.html { redirect_to @got_character, notice: 'Got character was successfully updated.' }\n format.json { render :show, status: :ok, location: @got_character }\n else\n format.html { render :edit }\n format.json { render json: @got_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character = Character.get(params[:id])\n params[:character] = params[:character].map { |x,y| [x, y.empty? ? nil : y ] }.to_hash\n\n respond_to do |format|\n if @character.update(params[:character])\n format.html { redirect_to([:administration, @character], :notice => 'Character was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @character.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @critic = Critic.find(params[:id])\n\n respond_to do |format|\n if @critic.update_attributes(params[:critic])\n format.html { redirect_to @critic, notice: 'Critic was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @critic.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @crust = Crust.find(params[:id])\n\n respond_to do |format|\n if @crust.update_attributes(params[:crust])\n format.html { redirect_to @crust, notice: 'Crust was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @crust.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cicle.update(cicle_params)\n format.html { redirect_to @cicle, notice: 'Cicle was successfully updated.' }\n format.json { render :show, status: :ok, location: @cicle }\n else\n format.html { render :edit }\n format.json { render json: @cicle.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @chronicle = Chronicle.find(params[:id])\n\n respond_to do |format|\n if @chronicle.update_attributes(params[:chronicle])\n format.html { redirect_to @chronicle, notice: 'Chronicle was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @chronicle.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character_race = CharacterRace.find(params[:id])\n\n if @character_race.update(character_race_params)\n head :no_content\n else\n render json: @character_race.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @objeto.update(caracteristica_params)\n set_redireccion\n format.html { redirect_to @redireccion, notice: 'Caracteristica was successfully updated.' }\n format.json { render :show, status: :ok, location: @objeto }\n else\n format.html { render :edit }\n format.json { render json: @objeto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @fundamental_character = Fundamental::Character.find(params[:id])\n\n respond_to do |format|\n if @fundamental_character.update_attributes(params[:fundamental_character])\n format.html { redirect_to @fundamental_character, notice: 'Character was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @fundamental_character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @character_class = CharacterClass.find(params[:id])\n\n if @character_class.update(character_class_params)\n head :no_content\n else\n render json: @character_class.errors, status: :unprocessable_entity\n end\n end",
"def update\n @contig = Contig.find(params[:id])\n\n respond_to do |format|\n if @contig.update_attributes(params[:contig])\n format.html { redirect_to @contig, notice: 'Contig was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @contig.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @icicle.update(icicle_params)\n format.html { redirect_to @icicle, notice: 'Icicle was successfully updated.' }\n format.json { render :show, status: :ok, location: @icicle }\n else\n format.html { render :edit }\n format.json { render json: @icicle.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /contacters/1 DELETE /contacters/1.json
|
def destroy
@contacter = Contacter.find(params[:id])
@contacter.destroy
respond_to do |format|
format.html { redirect_to contacters_url }
format.json { head :no_content }
end
end
|
[
"def destroy\n @contacter = Contacter.find(params[:id])\n @contacter.destroy\n\n respond_to do |format|\n format.html { redirect_to(bin_contacters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @caracter.destroy\n respond_to do |format|\n format.html { redirect_to caracters_url, notice: 'Caracter was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @caracteristica = Caracteristica.find(params[:id])\n @caracteristica.destroy\n\n respond_to do |format|\n format.html { redirect_to caracteristicas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n respond_to do |format|\n format.html { redirect_to characters_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cict.destroy\n respond_to do |format|\n format.html { redirect_to cicts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @critic = Critic.find(params[:id])\n @critic.destroy\n\n respond_to do |format|\n format.html { redirect_to critics_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @crust = Crust.find(params[:id])\n @crust.destroy\n\n respond_to do |format|\n format.html { redirect_to crusts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @characterline.destroy\n respond_to do |format|\n format.html { redirect_to characterlines_url, notice: 'Characterline was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @characteristic = Characteristic.find(params[:id])\n @characteristic.destroy\n\n respond_to do |format|\n format.html { redirect_to characteristics_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @caracteristicadeco1.destroy\n respond_to do |format|\n format.html { redirect_to caracteristicadeco1s_url, notice: 'Caracteristicadeco1 was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @critique_aile.destroy\n respond_to do |format|\n format.html { redirect_to critique_ailes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contig = Contig.find(params[:id])\n @contig.destroy\n\n respond_to do |format|\n format.html { redirect_to contigs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character_entry.destroy\n respond_to do |format|\n format.html { redirect_to character_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cicle.destroy\n respond_to do |format|\n format.html { redirect_to cicles_url, notice: 'Cicle was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @chruch.destroy\n respond_to do |format|\n format.html { redirect_to chruches_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @character.destroy\n\n respond_to do |format|\n format.html { redirect_to(characters_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @contadore.destroy\n respond_to do |format|\n format.html { redirect_to contadores_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @caracteristique.destroy\n respond_to do |format|\n format.html { redirect_to caracteristiques_url, notice: 'Caracteristique was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @contig.destroy\n respond_to do |format|\n format.html { redirect_to contigs_url }\n format.json { head :no_content }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
If the passphrase contains one of "i", "o" or "l", we should skip past all the subsequent strings in the sequence that will also contain these letters.
|
def skip_known_failures(passphrase)
passphrase.gsub(/[iol].+$/) { |m| m.chars.first.next + ('a' * m[1..-1].size) }
end
|
[
"def valid_subsequent_letters(letter)\n case letter\n when 'h'\n # i and j may or may not be skipped\n %w[i j k]\n when 'i'\n # j may or may not be skipped\n %w[j k]\n when 'k'\n # always skip l\n %w[m]\n when 'n'\n # always skip o\n %w[p]\n else\n [letter.succ]\n end\n end",
"def is_valid_passchars?(passphrase)\n words = passphrase.split(' ').map { |word| word.chars.sort.join('') }\n words.uniq.length == words.length\nend",
"def encryptor(user_pass)\n counter = 0\n output = \"\"\n while counter < user_pass.length\n\n if user_pass[counter] == \" \"\n output += \" \"\n elsif user_pass[counter] == \"z\"\n # conditional for \"z\"\n output += \"a\"\n else\n output += user_pass[counter].next\n end\n\n counter += 1\n\n end\n\n return output\nend",
"def block_word1?(str)\n counter = 0\n loop do\n return true if counter == str.size\n char = str[counter].upcase\n ascii_value = char.ord\n rest_of_str = str[(counter + 1)..-1]\n if ascii_value <= 77\n doppleganger = (ascii_value + 13).chr\n return false if rest_of_str.include?(doppleganger)\n else\n doppleganger = (ascii_value - 13).chr\n return false if rest_of_str.include?(doppleganger)\n end\n counter += 1\n end\nend",
"def three_letters_in_order?(password)\n #subtract two becuase we do not need to check the last nor the second to last\n # => characters for 3 ordered characters\n range = password.length - 2\n password.downcase!\n ordered_characters = false\n (0...range).each do |i|\n if password[i+1] == password[i].next && password[i+2] == password[i].next.next\n ordered_characters = true\n end\n end\n !ordered_characters\nend",
"def validate(passphrase)\n words = passphrase.split\n words == words.uniq\nend",
"def encrypt(string)\n counter = 0\n password = \"\"\n until counter == string.length\n if string[counter] == 'z'\n password = 'a'\n else\n password = string[counter].next + password\n end \n counter +=1\n end\n password.reverse\n\nend",
"def any_ambiguous_characters?(password)\n password.match(/[iol]/)\n end",
"def encrypt(secret_word)\r\n\t#keeps track of letters in word\r\n\tcounter = 0\r\n\t#loop through secret word replacing letter with next highest one\r\n\t#if statement prints 'a' instead of 'aa' if z is used in secret word\r\n\twhile counter < secret_word.length\r\n\t\tif secret_word[counter].next == \"aa\"\r\n\t\t\tprint \"a\"\r\n\t\t\tcounter += 1\r\n\t\telse\r\n\t\t\tprint secret_word[counter].next\r\n \t\t\tcounter += 1\r\n \t\tend\r\n\tend\r\n\t\r\n\tputs \"\"\r\nend",
"def encrypt(string)\n length = string.length\n\n\n encrypt_string = \"\"\n count = 0\n until count >= length\n if string[count] == \"z\"\n encrypt_string = encrypt_string + \"a\"\n\n else\n encrypt_string = encrypt_string + string[count].next\n end\n count += 1\n end\n p encrypt_string\nend",
"def valid_all_unique_no_anagrams?(passphrase)\n words = passphrase.split.map { |word| word.chars.sort.join }\n words.uniq == words\nend",
"def encrypt(password)\r\n\ti = 0\r\n\tdeck = \"\"\r\n\tlen = password.length\r\n\r\n\tfor i in 0...len\r\n\t\tdeck += password[i].next\r\n\t\tif password[i] == \"z\"\r\n\t\tdeck = deck.chomp(\"a\")\r\n\t\tend\r\n\t\tif password[i] == \"Z\"\r\n\t\tdeck = deck.chomp(\"A\")\r\n\t\tend\r\n\tend\r\n\treturn deck\r\nend",
"def validate(passphrase)\n words = passphrase.split\n permutations = words.map {|word| word.split('').permutation.map(&:join)}\n permutations.map!(&:uniq) # Gets rid of extra permutations from repeated words\n permutations.flatten!\n\n permutations == permutations.uniq\nend",
"def decrypt(seq_string)\n alphabets = \"abcdefghijklmnopqrstuvwxyz\"\n index = 0\n seq_string3 = \"\"\n while index < seq_string.length\n post_desired_letter = alphabets.index(seq_string[index])\n desired_letter = post_desired_letter - 1\n seq_string3 = seq_string3 + alphabets[desired_letter]\n index += 1\n end\n puts seq_string3\n\nend",
"def fail_letter?(letter)\n return @secret_word.include?(letter) ? false : letter\n end",
"def encrypt(pass)\n counter = 0\n password = \"\"\n\n until counter == pass.length\n alphabet = \"abcdefghijklmnopqrstuvwxyza\"\n letter = alphabet.index(pass[counter]) + 1\n counter += 1\n password = alphabet[letter] + password\n\n end\n password.reverse\n end",
"def decrypt(word)\n counter = 0 \n password = \"\"\n until counter == word.length\n alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n letter = alphabet.index(word[counter]) - 1\n counter += 1 \n password = alphabet[letter] + password\n end \n password.reverse\n \n end",
"def encrypt(password)\n index = 0\n until index == password.to_s.length #The .to_s was helpful in overcoming nil-related errors\n if password[index] == \"z\" #Handles edge case\n password[index] = \"a\"\n elsif password[index] == \" \" #Handles blank spaces\n password[index] = \" \"\n else\n password[index] = password[index].next #Primary encryption rule\n end\n index += 1 #Progresses encryption to the character in the next index position\n end\nend",
"def next_key?(line)\n same_trial?(line) &&\n (@data_type == :salt && line[:pos_char_onphrase] == @prev_pos_char + 1 ||\n @data_type == :pepper)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A method that attempts to render content from rit and if none found will raise an error Arguments: layout_name: +String+ The name of the rit layout instance_name: +String+ The name of the rit instance (optional) plate_name: +String+ The name of the rit plate Returns: Returns content (string) or raises error if not found
|
def rit_plate!(layout_name, instance_name, plate_name)
Rit::Plate.get(layout_name, instance_name, plate_name, session[:preview_time])
end
|
[
"def rit_plate!(layout_name, instance_name, plate_name)\n RitClient::Plate.get(layout_name, instance_name, plate_name, nil) # session[:preview_time]\n end",
"def render_content_in_layout(layout, object)\n content = object.matter\n layout.gsub /\\{\\{(.+?)\\}\\}/ do |tag_invocation|\n if md = tag_invocation.match(/^\\{\\{\\s*?(\\w+)(.*?)\\}\\}$/)\n tag = md[1]\n token_string = md[2]\n tokens = Hash[ token_string.strip.split(/\\s+/).collect {|token| token.split(\"=\").collect{|key_val| key_val.gsub(/\\W/,\"\") } } ]\n\n if tag == \"content\"\n\n if key = tokens[\"key\"]\n logger.debug \"Within content tag, attempting to render key `#{key}`\"\n content_value = object.matter.send(key)\n if content_value\n content_tag :span, :class=>\"editable\", \"data-content-type\"=>object.class.to_s.underscore, \"data-content-id\"=>object.id, \"data-content-key\"=>key do\n render_markdown object.matter.send(key)\n end\n else\n content_tag :span, \"Content region \\\"#{key}\\\" not specified within matter.\", :class=>\"error parse-error ui-state-error\"\n end\n else\n content_tag :span, \"Layout tag \\\"#{tag}\\\" requires providing a \\\"key\\\" attribute for proper parsing.\", :class=>\"error parse-error ui-state-error\"\n end\n\n else # if content\n content_tag :span, \"Unsupported layout tag \\\"#{tag}\\\" caused parsing error\", :class=>\"error parse-error ui-state-error\"\n end # if content\n else\n content_tag :span, \"Tag #{tag} with token string #{token_string} caused parsing error.\", :class=>\"error parse-error ui-state-error\"\n end\n\n end.html_safe\n end",
"def render\n template_body = Tilt.new(@template).render(self)\n if @layout\n layout = Dir[File.join(File.dirname(@template), @layout) + '*'].first\n raise \"#{Guinness::EMOJI} Guinness : Unable to locate layout at: '#{@layout}'\" unless layout\n @body = Tilt.new(layout).render(self) { template_body }\n end\n @body || template_body\n end",
"def render_content(format)\n begin\n ERB.new( File.open( template_path_for(format) ).read, nil, '%<>' ).result(self.get_binding)\n rescue TemplateUndefined\n ''\n end\n end",
"def render_layout name, options = {}\n path = Evo.theme.path_to \"views/#{name}.*\"\n raise Evo::LayoutMissingError, \"layout #{name.inspect} does not exist\" unless path\n before :rendering_layout, path\n Tilt.new(path).render self, options do |region, string|\n region ||= :primary\n content_for(region).sort_by(&:weight).map(&:to_html).join string\n end\n end",
"def rails_render(*args)\n rails_controller_instance.render_to_string(*args)\n rescue ActionView::MissingTemplate\n nil\n end",
"def render\n template_body = Tilt.new(@template).render(self)\n if @layout\n layout = Dir[File.join(File.dirname(@template), @layout) + '*'].first\n raise \"-: Snack :- Unable to locate layout at: '#@layout'\" unless layout\n @body = Tilt.new(layout).render(self) { template_body }\n end\n @body || template_body\n end",
"def get_content_for(view)\n run_defaults\n run_defaults(view)\n view = view.to_s\n \n view_path = ResourcefulViews.determine_view_path(controller, view) do |path_base, path_last|\n resource_check_template_exists?(\"#{path_base}/_#{path_last}\")\n end\n if view_path\n content_for(view) do\n render :partial => view_path\n end\n end\n \n to_return = eval \"@content_for_#{view}\"\n # logger.debug(\"get content is \" + to_return.inspect)\n \n # puts \"content for #{view} is #{to_return}\"\n return to_return\n end",
"def process_layout(config, widget_name)\n layout = nil\n layout_path = File.join(widget_name, 'layouts', \"#{config['layout']}.html\")\n [\n File.join(@ruhoh.paths.theme, \"widgets\", layout_path),\n File.join(@path, layout_path),\n File.join(@system_path, layout_path)\n ].each do |path|\n layout = path and break if File.exist?(path)\n end\n\n return '' unless layout\n content = File.open(layout, 'r:UTF-8') { |f| f.read }\n Mustache.render(content, {'config' => config})\n end",
"def render_with_layout(view_file_name,variables={})\n # read the file everytime for development ease\n erubis = Erubis::Eruby.new(File.read(File.join(VIEW_PATH,\"#{view_file_name}.html.erb\")))\n @layout.render({:content_body => erubis.result(variables) })\n end",
"def _render_layout_for( res )\n return unless res.layout\n lyt = Resources.layouts.find :filename => res.layout\n return if lyt.nil?\n\n _track_rendering(lyt.path) {\n @content = Filters.process(\n self, lyt, ::Webby::Resources::File.read(lyt.path))\n _render_layout_for(lyt)\n }\n end",
"def html_content\n # Handle empty content first by returning an error message\n if @object.content.blank?\n if @object.page_ref&.gleaning.content.blank?\n return GleaningPresenter.new(@object.page_ref&.gleaning, @template, @viewer).html_content\n elsif @object.page_ref&.trimmed_content.blank?\n return PageRefPresenter.new(@object.page_ref, @template, @viewer).html_content\n end\n end\n\n hc = if content_for(:rp_inglist).present? && content_for(:rp_instructions).present?\n with_format('html') { render 'recipes/formatted_content', presenter: self, locals: {presenter: self} }\n else\n (@object.content || '').html_safe\n end\n if response_service.admin_view? && @object.content\n hc += content_tag(:h2, 'Raw Parsed Content -------------------------------') + @object.content.html_safe\n end\n hc\n end",
"def render name, options = {}\n partial = options.delete :partial\n if partial\n parts = name.to_s.split '/'\n parts[-1] = \"_#{parts.last}\"\n name = File.join parts\n end\n path = theme.path_to_view((options[:package] || package).name / name)\n path ||= (options[:package] || package).path_to_view name\n raise Evo::ViewMissingError, \"view #{name.inspect} does not exist\" unless path\n output = Tilt.new(path).render options.fetch(:context, self), options\n if !partial && options.delete(:layout) != false\n content_for :primary, output\n return render_layout(:page, options)\n end\n output\n rescue Evo::LayoutMissingError\n output\n end",
"def find_rendered( id )\n begin\n ( Regulate.repo.tree / File.join( id , 'rendered.html' ) ).data\n rescue\n nil\n end\n end",
"def fetch_template_from_url\n layout_url = lookup_template_url\n return nil if layout_url == nil\n\n Rails.logger.info \"Fetching remote template from #{layout_url.inspect}\"\n\n response = Curl.get( layout_url ) do |curl| \n curl.timeout = self.http_timeout\n end\n response_body = response.body_str\n\n Rails.logger.info \"Got remote template response code #{response.response_code} with body #{response_body.inspect}\"\n\n return nil if response.response_code == 404\n \n response_body = postprocess_template( response_body ) if respond_to?( :postprocess_template, true )\n\n return response_body\n \n rescue SocketError, Curl::Err::TimeoutError, Errno::ECONNREFUSED, TemplateRejectedError => e\n Rails.logger.error e.message\n return nil\n end",
"def getRenderEngineByName( name )\n\n # parameter TypeCheck\n #BIMserverAPI::TypeCheck::String( name )\n\n # BIMserver request\n request( { name: name } )\n end",
"def render_standalone_template\n begin\n return render(:template => \"templates/#{params[:renders_with]}\", :layout => !request.xhr?) \n rescue ActionView::MissingTemplate\n redirect_to('/404.html')\n end\n end",
"def render r\n validate_components!\n r.render self\n r\n end",
"def content\n key = self.primkey\n\n _class = Classname.model(self.code.name)\n if _class\n _class.find key\n\n else\n if key[/LAYOUT/]\n Web::PortletPreferences.find(:first, :conditions => \"plid=#{self.plid} AND portletid='#{self.portletid}'\" )\n else\n # unless groups_ids.include? key\n STDERR.puts \"fixme: #{self.code.name} (#{key})\"\n return nil\n # end\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /fotos_empresas GET /fotos_empresas.json
|
def index
@fotos_empresas = FotosEmpresa.all
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 show\n @fotosresposta = Fotosresposta.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @fotosresposta}\n end\n end",
"def index\n @photos = Photo.all\n\n render json: @photos\n end",
"def index\n @votos = Voto.all\n\n render json: @votos\n end",
"def index\n @fotos_estabs = FotosEstab.all\n end",
"def index\n if params[:single]\n\t url = \"#{API_BASE_URL}/photos/#{params[:id]}.json?token=#{ENV['API_KEY']}\"\n\t response = RestClient.get(url)\n\t @photo = JSON.parse(response.body)\n\telse\n\t url = \"#{API_BASE_URL}/photos.json?token=#{ENV['API_KEY']}\"\n response = RestClient.get(url)\n @photos = JSON.parse(response.body)\t\t \n\tend\n end",
"def index\n @fotos = Foto.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @fotos }\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 fotos_naturalista\n ficha_naturalista_api_nodejs\n return unless jres[:estatus]\n\n fotos = jres[:ficha]['taxon_photos']\n self.jres = jres.merge({ fotos: fotos })\n end",
"def index\n @imagens = Imagem.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @imagens }\n end\n end",
"def index\n @imagems = Imagem.where(:imovel_id => current_user.imovels {|i| i.id})\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @imagems }\n end\n end",
"def show\n @employer_photo = EmployerPhoto.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @employer_photo }\n end\n end",
"def show\n @foto_galeri = FotoGaleri.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @foto_galeri }\n end\n end",
"def index\n @apparel_images = ApparelImage.all\n\n render json: @apparel_images\n end",
"def new\n @foto = Fotosresposta.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @foto }\n end\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 index\n @especie = Especie.find(params[:especie_id])\n @especie_imagens = EspecieImagem.find(@especie.especie_imagens)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @especie_imagens }\n end\n end",
"def index\n @pictures = Picture.where(foodscape_id: params[:foodscape_id])\n render json: @pictures\n end",
"def index\n @post_photos = PostPhoto.all\n # render json:Post.all\n # render json:PostPhoto.all\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /fotos_empresas POST /fotos_empresas.json
|
def create
@fotos_empresa = FotosEmpresa.new(fotos_empresa_params)
respond_to do |format|
if @fotos_empresa.save
format.html { redirect_to @fotos_empresa, notice: 'Fotos empresa was successfully created.' }
format.json { render :show, status: :created, location: @fotos_empresa }
else
format.html { render :new }
format.json { render json: @fotos_empresa.errors, status: :unprocessable_entity }
end
end
end
|
[
"def create\n \n @foto = Fotosresposta.new(params[:fotosresposta])\n\n respond_to do |format|\n if @foto.save\n format.html { redirect_to @foto, notice: 'Respostas Criadas com Sucesso.' }\n format.json { render json: @foto, status: :created, location: @foto}\n else\n format.html { render action: \"new\" }\n format.json { render json: @foto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @fotos_estab = FotosEstab.new(fotos_estab_params)\n\n respond_to do |format|\n if @fotos_estab.save\n format.html { redirect_to @fotos_estab, notice: 'Fotos estab was successfully created.' }\n format.json { render action: 'show', status: :created, location: @fotos_estab }\n else\n format.html { render action: 'new' }\n format.json { render json: @fotos_estab.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @fotos_empresas = FotosEmpresa.all\n end",
"def new\n @foto = Fotosresposta.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @foto }\n end\n end",
"def fotos_naturalista\n ficha_naturalista_api_nodejs\n return unless jres[:estatus]\n\n fotos = jres[:ficha]['taxon_photos']\n self.jres = jres.merge({ fotos: fotos })\n end",
"def save_temp_photos\n begin\n params[:temp_photo][:image].each do |tmp|\n Business::TempPhoto.create(:image => tmp[1], :token_id => params[:temp_photo][:questionnaire_token])\n end\n render json: {status: 'success'}\n rescue\n render json: {status: 'error'}\n end\n end",
"def create\n @aprov_estab = AprovEstab.new(aprov_estab_params)\n @fotos_estab = @aprov_estab.fotos_estab.build\n\n respond_to do |format|\n if @aprov_estab.save\n format.html { redirect_to @aprov_estab, notice: 'Aprov estab was successfully created.' }\n format.json { render action: 'show', status: :created, location: @aprov_estab }\n else\n format.html { render action: 'new' }\n format.json { render json: @aprov_estab.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @foto_artigo = FotoArtigo.new(foto_artigo_params)\n\n respond_to do |format|\n if @foto_artigo.save\n format.html { redirect_to @foto_artigo, notice: 'Foto artigo was successfully created.' }\n format.json { render :show, status: :created, location: @foto_artigo }\n else\n format.html { render :new }\n format.json { render json: @foto_artigo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @photos = Photo.new(photos_params)\n if @photos.save\n render json: { id: @photos.id, url: @photos.gallery.url,\n size: @photos.gallery_file_size }\n else\n render json: { id: nil }\n end\n end",
"def create\n @empresa = Empresa.new(empresa_params)\n\n if @empresa.save\n render json: @empresa, status: :created, location: @empresa\n else\n render json: @empresa.errors, status: :unprocessable_entity\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 create\n @fotos_in = FotosIn.new(fotos_in_params)\n\n respond_to do |format|\n if @fotos_in.save\n format.html { redirect_to @fotos_in, notice: 'Fotos in was successfully created.' }\n format.json { render action: 'show', status: :created, location: @fotos_in }\n else\n format.html { render action: 'new' }\n format.json { render json: @fotos_in.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @proyecto_imagen = ProyectoImagen.new(params[:proyecto_imagen])\n\n if @proyecto_imagen.save\n respond_to do |format|\n format.html {\n render :json => [@proyecto_imagen.to_jq_upload].to_json,\n :content_type => 'text/html',\n :layout => false\n }\n format.json {\n render :json => [@proyecto_imagen.to_jq_upload].to_json\n }\n end\n else\n render :json => [{:error => \"custom_failure\"}], :status => 304\n end\n end",
"def upload_image\n res = []\n params[:images].each do |image|\n image = ContentFile.new(image: image, tmp_key: params[:tmp_images_key])\n if image.save\n res << {id: image.id, url: image.image.url(:thumb)}\n else\n res << {errors: image.errors.full_messages.join(', ')}\n end\n end\n render json: res\n end",
"def create\n @objeto = Imagen.new(imagen_params)\n\n respond_to do |format|\n if @objeto.save\n set_redireccion\n format.html { redirect_to @redireccion, notice: 'Imagen was successfully created.' }\n format.json { render :show, status: :created, location: @objeto }\n else\n format.html { render :new }\n format.json { render json: @objeto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @egreso = Egreso.new(params[:egreso])\n\n respond_to do |format|\n if @egreso.save\n format.html { redirect_to @egreso, notice: 'Egreso was successfully created.' }\n format.json { render json: @egreso, status: :created, location: @egreso }\n else\n format.html { render action: \"new\" }\n format.json { render json: @egreso.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @egreso = Egreso.new(egreso_params)\n\n respond_to do |format|\n if @egreso.save\n format.html { redirect_to @egreso, notice: 'Egreso was successfully created.' }\n format.json { render :show, status: :created, location: @egreso }\n else\n format.html { render :new }\n format.json { render json: @egreso.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @album = Album.find(params[:album_id])\n @photo = @album.photos.new(params[:photo])\n \n if @photo.save \n # AW\n # had to override to use gem and multiphoto upload \n # there is the manual input of json, found under views/photos/create.json.jbuilder\n else\n render :json => { \"errors\" => @photo.errors } \n end\n end",
"def create\n @emerito = Emerito.new(emerito_params)\n\n respond_to do |format|\n if @emerito.save\n format.html { redirect_to @emerito, notice: 'Emerito was successfully created.' }\n format.json { render :show, status: :created, location: @emerito }\n else\n format.html { render :new }\n format.json { render json: @emerito.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PATCH/PUT /fotos_empresas/1 PATCH/PUT /fotos_empresas/1.json
|
def update
respond_to do |format|
if @fotos_empresa.update(fotos_empresa_params)
format.html { redirect_to @fotos_empresa, notice: 'Fotos empresa was successfully updated.' }
format.json { render :show, status: :ok, location: @fotos_empresa }
else
format.html { render :edit }
format.json { render json: @fotos_empresa.errors, status: :unprocessable_entity }
end
end
end
|
[
"def update\n @foto = Fotosresposta.find(params[:id])\n\n respond_to do |format|\n if @foto.update_attributes(params[:fotosresposta])\n format.html { redirect_to @foto, notice: 'Respostas actualizadas com sucesso.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @foto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fotos_in.update(fotos_in_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: @fotos_in.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @fotos_estab.update(fotos_estab_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: @fotos_estab.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @photo = resource.photos.find(params[:id])\n \n\n respond_to do |format|\n if @photo.update_attributes(photo_params)\n format.json { head :no_content }\n logger.info(\"save photo\")\n logger.info photo_params[\"photo_type_id\"]\n else\n format.html { render action: \"edit\" }\n format.json { render json: @photo.errors, status: :unprocessable_entity, notice: 'Error.' }\n end\n end\n end",
"def update\n respond_to do |format|\n if @photo_event.update(photo_event_params)\n format.html { redirect_to @photo_event, notice: 'Foto de evento actualizada com sucesso.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @photo_event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tifo.update(tifo_params)\n format.html { redirect_to tifo_photos_path(tifo_id: @tifo.token), notice: 'Tifo was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @tifo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @objeto.update(imagen_params)\n set_redireccion\n format.html { redirect_to @redireccion, notice: 'Imagen was successfully updated.' }\n format.json { render :show, status: :ok, location: @objeto }\n else\n format.html { render :edit }\n format.json { render json: @objeto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n respond_to do |format|\r\n if @photo_service.update(photo_service_params)\r\n format.html { redirect_to @photo_service, notice: 'Serviço de fotos actualizado com sucesso.' }\r\n format.json { head :no_content }\r\n else\r\n format.html { render action: 'edit' }\r\n format.json { render json: @photo_service.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n respond_to do |format|\n if @photo.update(photo_params)\n save_to_json\n format.html { redirect_to @photo, notice: 'Photo was successfully updated.' }\n format.json { render :show, status: :ok, location: @photo }\n else\n format.html { render :edit }\n format.json { render json: @photo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n puts y params['photo'].keys\n params['photo'].keys.each do |photo_id|\n photo = Photo.find(photo_id)\n photo.update_attributes(params['photo'][photo_id])\n end\n respond_to do |format|\n if true \n format.html { redirect_to photos_path, notice: 'Photos were successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"index\" }\n format.json { render json: @photo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @inventario = Inventario.find(params[:id])\n @foto = @inventario.foto\n \n @service = InventarioService.new(@inventario, @foto)\n respond_to do |format|\n\n if @inventario.update_attributes(params[:inventario],params[:foto_file])\n format.html { redirect_to(@inventario, :notice => 'Inventario was successfully updated.') }\n format.xml { head :ok }\n else\n\t @foto = @service.foto\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @inventario.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n # spot = HTTParty.get(\"http://localhost:3000/spots/#{params[:id]}\" )\n if @spot.update(spot_params)\n HTTParty.patch(\"http://localhost:3000/spots/#{params[:id]}?name=#{spot_params[:name]}&lat=#{spot_params[:lat]}&lon=#{spot_params[:lon]}&description=#{spot_params[:description]}&features=#{spot_params[:features]}&spot_type=#{spot_params[:spot_type]}&img=#{spot_params[:img]}\")\n @spot.spot_photos.attach(params[:spot][:spot_photos])\n format.html { redirect_to @spot, notice: 'Spot was successfully updated.' }\n format.json { render :show, status: :ok, location: @spot }\n else\n format.html { render :edit }\n format.json { render json: @spot.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @foto_artigo.update(foto_artigo_params)\n format.html { redirect_to @foto_artigo, notice: 'Foto artigo was successfully updated.' }\n format.json { render :show, status: :ok, location: @foto_artigo }\n else\n format.html { render :edit }\n format.json { render json: @foto_artigo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @aimagen = Aimagen.find(params[:id])\n\n respond_to do |format|\n if @aimagen.update_attributes(params[:aimagen])\n format.html { redirect_to @aimagen, notice: 'imagen actualizada.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @aimagen.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @productos_json.update(productos_json_params)\n format.html { redirect_to @productos_json, notice: 'Productos json was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @productos_json.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @emprestimos.update(emprestimo_params)\n format.html { redirect_to @emprestimo, notice: 'emprestimo atualizado com sucesso.' }\n format.json { render :show, status: :ok, location: @emprestimo }\n else\n format.html { render :edit }\n format.json { render json: @emprestimo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @imagen_pedido = ImagenPedido.find(params[:id])\n\n respond_to do |format|\n if @imagen_pedido.update_attributes(params[:imagen_pedido])\n format.html { redirect_to @imagen_pedido, notice: 'Imagen pedido was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @imagen_pedido.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @empresa = Empresa.find(params[:id])\n\n if @empresa.update(empresa_params)\n head :no_content\n else\n render json: @empresa.errors, status: :unprocessable_entity\n end\n end",
"def update\n @emprestimo = Emprestimo.find(params[:id])\n\n respond_to do |format|\n if @emprestimo.update_attributes(params[:emprestimo])\n format.html { redirect_to @emprestimo, notice: 'Emprestimo was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @emprestimo.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /fotos_empresas/1 DELETE /fotos_empresas/1.json
|
def destroy
@fotos_empresa.destroy
respond_to do |format|
format.html { redirect_to fotos_empresas_url, notice: 'Fotos empresa was successfully destroyed.' }
format.json { head :no_content }
end
end
|
[
"def destroy\n @fotos_estab.destroy\n respond_to do |format|\n format.html { redirect_to fotos_estabs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @fotosresposta = Fotosresposta.find(params[:id])\n @fotosresposta.destroy\n\n respond_to do |format|\n format.html { redirect_to fotosresposta_url }\n format.json { head :no_content }\n end\n end",
"def delete_floor_plan(args = {}) \n delete(\"/files.json/floorplan/images\", args)\nend",
"def destroy\n @fotos_in.destroy\n respond_to do |format|\n format.html { redirect_to fotos_ins_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @aimagen = Aimagen.find(params[:id])\n @aimagen.destroy\n\n respond_to do |format|\n format.html { redirect_to aimagens_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @imagene.destroy\n respond_to do |format|\n format.html { redirect_to imagenes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foto = Foto.find(params[:id])\n @foto.destroy\n\n respond_to do |format|\n format.html { redirect_to fotos_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @sample_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def delete_temp_photos\n begin\n temp_photo = Business::TempPhoto.find(params[:id])\n temp_photo.destroy\n render json: {status: 'success'}\n rescue\n render json: {status: 'error'}\n end\n end",
"def destroy\n @structure_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def destroy\n @imagen_pedido = ImagenPedido.find(params[:id])\n @imagen_pedido.destroy\n\n respond_to do |format|\n format.html { redirect_to imagen_pedidos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foto_galeri = FotoGaleri.find(params[:id])\n @foto_galeri.destroy\n\n respond_to do |format|\n format.html { redirect_to foto_galeris_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @photo1 = Photo1.find(params[:id])\n @photo1.destroy\n\n respond_to do |format|\n format.html { redirect_to photo1s_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rock_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def destroy\n @restaurant_photo = RestaurantPhoto.find(params[:id])\n @restaurant_photo.destroy\n\n respond_to do |format|\n format.html { redirect_to restaurant_photos_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 @admin_post_photo.destroy\n respond_to do |format|\n format.html { redirect_to admin_post_photos_url, notice: 'Foto excluída com sucesso.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @egreso = Egreso.find(params[:id])\n @egreso.destroy\n\n respond_to do |format|\n format.html { redirect_to egresos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @json.destroy\n\n head :no_content\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Is this an scp formatted uri? (Yes, always)
|
def scp?
true
end
|
[
"def scp?\n false\n end",
"def is_puppet_url(url)\n \t\turl =~ /^puppet:\\/\\//\n \tend",
"def absolute_url?(string); end",
"def validate_uri(uri)\n unless uri.is_a?(String)\n return false\n end\n\n unless uri.slice(GIT_REGEXP).nil?\n return true\n end\n\n unless uri.slice(SCP_REGEXP).nil?\n return true\n end\n\n false\n end",
"def url?(uri)\n /\\w+\\:\\/\\// =~ uri\n end",
"def ssh?\n !!normalized_scheme.to_s.match(/ssh/)\n end",
"def opensdg_is_path_remote(path)\n if path.nil?\n return false\n end\n return path.start_with?('http')\nend",
"def uriish? str\r\n (str.include? ':') && str =~ UriSniffRx\r\n end",
"def uriish? str\n (str.include? ':') && (UriSniffRx.match? str)\n end",
"def file_uri?(uri)\n uri =~ %r{\\Afile://}\n end",
"def migrate_linked_file?(uri)\n host = uri.host.to_s\n path = uri.path.to_s\n if(host == 'www.ctcc.uio.no')\n if(path != '/' and path != '')\n return true\n else\n return false\n end\n elsif(host != '')\n return false\n end\n return super(uri)\n end",
"def is_url?\n path =~ URL_PATHS\n end",
"def validate_uri(uri)\n unless uri.is_a?(String)\n return false\n end\n\n unless uri.slice(SSH_REGEXP).nil?\n return true\n end\n\n unless uri.slice(GIT_REGEXP).nil?\n return true\n end\n\n false\n end",
"def migrate_linked_file?(uri)\n host = uri.host.to_s\n path = uri.path.to_s\n if(host == 'www.cma.uio.no')\n if(path != '/' and path != '')\n return true\n else\n return false\n end\n elsif(host != '')\n return false\n end\n return super(uri)\n end",
"def valid_git_ssh_url?(url)\n url.match(GIT_SSH_URL_REGEX)\n end",
"def is_local? path\n uri = URI.parse(path)\n uri.scheme.nil? && uri.host.nil?\n rescue URI::BadURIError\n false\n rescue URI::InvalidURIError\n false\n end",
"def is_ppa_url?(url)\n url.start_with?(\"ppa:\")\n end",
"def mirror?\n source_type == 'url'\n end",
"def is_local\n return @path[0,7] == \"file://\"\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /pagina_principals POST /pagina_principals.json
|
def create
@pagina_principal = PaginaPrincipal.new(pagina_principal_params)
respond_to do |format|
if @pagina_principal.save
format.html { redirect_to @pagina_principal, notice: 'Pagina principal was successfully created.' }
format.json { render :show, status: :created, location: @pagina_principal }
else
format.html { render :new }
format.json { render json: @pagina_principal.errors, status: :unprocessable_entity }
end
end
end
|
[
"def valid_principals; end",
"def create\n @principio_ativo = PrincipioAtivo.new(params[:principio_ativo])\n\n respond_to do |format|\n if @principio_ativo.save\n format.html { redirect_to @principio_ativo, notice: 'Principio ativo was successfully created.' }\n format.json { render json: @principio_ativo, status: :created, location: @principio_ativo }\n else\n format.html { render action: \"new\" }\n format.json { render json: @principio_ativo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def valid_principals=(_arg0); end",
"def create\n authorize! :index, @user, :message => 'Not authorized.'\n @principal = Principal.new(params[:principal])\n\n respond_to do |format|\n if @principal.save\n format.html { redirect_to @principal, notice: 'Principal was successfully created.' }\n format.json { render json: @principal, status: :created, location: @principal }\n else\n format.html { render action: \"new\" }\n format.json { render json: @principal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @principio_ativo = PrincipioAtivo.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @principio_ativo }\n end\n end",
"def index\n unless current_user && current_user\n redirect_to root_path\n end\n @principals = Principal.all\n end",
"def create\n @principalelement = Principalelement.new(principalelement_params)\n\n respond_to do |format|\n if @principalelement.save\n format.html { redirect_to '/principal/index', notice: 'Principalelement was successfully created.' }\n format.json { render :show, status: :created, location: @principalelement }\n else\n format.html { render :new }\n format.json { render json: @principalelement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @principal = Principal.new(params[:principal])\n \n respond_to do |format|\n if @principal.save\n format.html { redirect_to(@principal, :notice => 'Ihr Auftraggeberprofil wurde erfolgreich erstellt.') }\n format.xml { render :xml => @principal, :status => :created, :location => @principal }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @principal.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def index\n @principals = Principal.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @principals }\n end\n end",
"def index\n @slider_principals = SliderPrincipal.all\n end",
"def create\n @principalgroupe = Principalgroupe.new(principalgroupe_params)\n\n respond_to do |format|\n if @principalgroupe.save\n format.html { redirect_to @principalgroupe, notice: 'Principalgroupe was successfully created.' }\n format.json { render :show, status: :created, location: @principalgroupe }\n else\n format.html { render :new }\n format.json { render json: @principalgroupe.errors, status: :unprocessable_entity }\n end\n end\n end",
"def insertar_lista_principio(referencia)\n if @principio != nil && @principio.siguiente != nil\n n = @principio\n @principio = Nodo.new(referencia, n, nil)\n n.anterior = @principio\n elsif @principio != nil\n n = @principio\n @principio = Nodo.new(referencia, n, nil)\n n.anterior = @principio\n @final = n\n else\n @principio = Nodo.new(referencia, nil, nil)\n @final = @principio\n end\n end",
"def create\n @principal_groupe = PrincipalGroupe.new(principal_groupe_params)\n\n respond_to do |format|\n if @principal_groupe.save\n format.html { redirect_to @principal_groupe, notice: 'Principal groupe was successfully created.' }\n format.json { render :show, status: :created, location: @principal_groupe }\n else\n format.html { render :new }\n format.json { render json: @principal_groupe.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @intranet_privilegio = Intranet::Privilegio.new(intranet_privilegio_params)\n\n respond_to do |format|\n if @intranet_privilegio.save\n format.html { redirect_to @intranet_privilegio, notice: \"Privilegio was successfully created.\" }\n format.json { render :show, status: :created, location: @intranet_privilegio }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @intranet_privilegio.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @relatorio_psicologicos = RelatorioPsicologico.all\n authorize @relatorio_psicologicos\n\n @relatorio_psicologico = RelatorioPsicologico.new(relatorio_psicologico_params)\n\n respond_to do |format|\n if @relatorio_psicologico.save\n format.html { redirect_to @relatorio_psicologico, notice: 'Relatório psicológico criado com sucesso!' }\n format.json { render :show, status: :created, location: @relatorio_psicologico }\n else\n format.html { render :new }\n format.json { render json: @relatorio_psicologico.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @principio_ativo = PrincipioAtivo.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @principio_ativo }\n end\n end",
"def index\n @principalelements = Principalelement.all\n end",
"def create\n @usuario_prestamo = UsuarioPrestamo.new(usuario_prestamo_params)\n authorize! :crear, @usuario_prestamo\n respond_to do |format|\n if @usuario_prestamo.save\n format.html { redirect_to @usuario_prestamo, notice: 'El usuario de préstamo fue agregado correctamente' }\n format.json { render :show, status: :created, location: @usuario_prestamo }\n else\n format.html { render :new }\n format.json { render json: @usuario_prestamo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def search_principals(search_properties, test = 'allof')\n result = @principal_backend.search_principals(@principal_prefix, search_properties, test)\n r = []\n\n result.each do |row|\n r << Http::UrlUtil.split_path(row)[1]\n end\n\n r\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PATCH/PUT /pagina_principals/1 PATCH/PUT /pagina_principals/1.json
|
def update
respond_to do |format|
if @pagina_principal.update(pagina_principal_params)
format.html { redirect_to @pagina_principal, notice: 'Pagina principal was successfully updated.' }
format.json { render :show, status: :ok, location: @pagina_principal }
else
format.html { render :edit }
format.json { render json: @pagina_principal.errors, status: :unprocessable_entity }
end
end
end
|
[
"def update_principal(path, prop_patch)\n end",
"def update\n @principio_ativo = PrincipioAtivo.find(params[:id])\n\n respond_to do |format|\n if @principio_ativo.update_attributes(params[:principio_ativo])\n format.html { redirect_to @principio_ativo, notice: 'Principio ativo was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @principio_ativo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :index, @user, :message => 'Not authorized.'\n @principal = Principal.find(params[:id])\n\n respond_to do |format|\n if @principal.update_attributes(params[:principal])\n format.html { redirect_to @principal, notice: 'Principal was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @principal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @principalelement.update(principalelement_params)\n format.html { redirect_to '/principal/index', notice: 'Principalelement was successfully updated.' }\n format.json { render :show, status: :ok, location: @principalelement }\n else\n format.html { render :edit }\n format.json { render json: @principalelement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_principal(path, prop_patch)\n value = nil\n principal_index = nil\n principal = nil\n\n @principals.each_with_index do |value, i|\n principal_index = i\n if value['uri'] == path\n principal = value\n break\n end\n end\n\n return nil unless principal\n\n prop_patch.handle_remaining(\n lambda do |mutations|\n mutations.each do |prop, value|\n if value.nil? && principal.key?(prop)\n principal.delete(prop)\n else\n principal[prop] = value\n end\n end\n\n @principals[principal_index] = principal\n\n return true\n end\n )\n end",
"def update\n respond_to do |format|\n if @partida_parcial.update(partida_parcial_params)\n format.html { redirect_to @partida_parcial, notice: 'La Partida parcial fue modificada exitosamente.' }\n format.json { render :show, status: :ok, location: @partida_parcial }\n else\n @partidas_principales = PartidaPrincipal.all \n format.html { render :edit }\n format.json { render json: @partida_parcial.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @principal = Principal.find(params[:id])\n\n respond_to do |format|\n if @principal.update_attributes(params[:principal])\n format.html { redirect_to(@principal, :notice => 'Principal was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @principal.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @relatorio_psicologicos = RelatorioPsicologico.all\n authorize @relatorio_psicologicos\n\n respond_to do |format|\n if @relatorio_psicologico.update(relatorio_psicologico_params)\n format.html { redirect_to @relatorio_psicologico, notice: 'Relatório psicológico atualizado com sucesso!' }\n format.json { render :show, status: :ok, location: @relatorio_psicologico }\n else\n format.html { render :edit }\n format.json { render json: @relatorio_psicologico.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @pelicula = Pelicula.find(params[:id])\n @pelicula.update(update_params)\n render json: @pelicula, status: :ok\n end",
"def update\n respond_to do |format|\n if @principalgroupe.update(principalgroupe_params)\n format.html { redirect_to @principalgroupe, notice: 'Principalgroupe was successfully updated.' }\n format.json { render :show, status: :ok, location: @principalgroupe }\n else\n format.html { render :edit }\n format.json { render json: @principalgroupe.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @principal_establec = PrincipalEstablec.find(params[:id])\n\n respond_to do |format|\n if @principal_establec.update_attributes(params[:principal_establec])\n format.html { redirect_to @principal_establec, notice: 'Registro editado satisfactoriamente.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @principal_establec.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @palabra = Palabra.find(params[:id])\n @palabra.significados = params[:significados] \n respond_to do |format|\n if @palabra.update_attributes(params[:palabra])\n format.html { redirect_to @palabra, notice: 'La Palabra fue actualizada correctamente.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @palabra.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if not ( paziente_signed_in? or administrator_signed_in?)\n redirect_to root_path and return\n end\n respond_to do |format|\n if @profilopazienti.update(profilopazienti_params)\n format.html { redirect_to @profilopazienti, notice: \"Profilopazienti was successfully updated.\" }\n format.json { render :show, status: :ok, location: @profilopazienti }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @profilopazienti.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @oficio_prefeitura.update(oficio_prefeitura_params)\n respond_with( [ :admin, @oficio_prefeitura] )\n end",
"def update\n @prefecture.objectId = params[\"id\"]\n @prefecture.regionId = params[\"r_id\"]\n @prefecture.name = params[\"name\"]\n @prefecture.acl = nil\n respond_to do |format|\n if @prefecture.save\n format.html { redirect_to prefecture_path(params['id']), notice: \"Prefecture was successfully updated.\" }\n format.json { render :show, status: :ok, location: @prefecture }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @prefecture.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @pagina = Pagina.find(params[:id])\n\n respond_to do |format|\n if @pagina.update_attributes(params[:pagina])\n format.html { redirect_to :back, notice: 'Pagina was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pagina.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :manage, Pupil\n respond_to do |format|\n if @pupil.update(pupil_attrs)\n format.html { redirect_to @pupil, notice: t('action.update.succeed', entity: Pupil.model_name.human) }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @pupil.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :editar, @usuario_prestamo\n respond_to do |format|\n if @usuario_prestamo.update(usuario_prestamo_params)\n format.html { redirect_to @usuario_prestamo, notice: 'La información del usuario de préstamos ha sido modificada correctamente' }\n format.json { render :show, status: :ok, location: @usuario_prestamo }\n else\n format.html { render :edit }\n format.json { render json: @usuario_prestamo.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"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /pagina_principals/1 DELETE /pagina_principals/1.json
|
def destroy
@pagina_principal.destroy
respond_to do |format|
format.html { redirect_to pagina_principals_url, notice: 'Pagina principal was successfully destroyed.' }
format.json { head :no_content }
end
end
|
[
"def destroy\n @principio_ativo = PrincipioAtivo.find(params[:id])\n @principio_ativo.destroy\n\n respond_to do |format|\n format.html { redirect_to principio_ativos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n authorize! :index, @user, :message => 'Not authorized.'\n @principal = Principal.find(params[:id])\n @principal.destroy\n\n respond_to do |format|\n format.html { redirect_to principals_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @principal = Principal.find(params[:id])\n @principal.destroy\n\n respond_to do |format|\n format.html { redirect_to(principals_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @perfilusuario = Perfilusuario.find(params[:id])\n @perfilusuario.destroy\n respond_to do |format|\n format.html { redirect_to perfilusuarios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @pelicula = Pelicula.find(params[:id])\n @pelicula.destroy\n render json: {message: 'Eliminated'}, status: :ok\n\n end",
"def destroy\n @pagina = Pagina.find(params[:id])\n @pagina.destroy\n\n respond_to do |format|\n format.html { redirect_to :back }\n format.json { head :no_content }\n end\n end",
"def destroy\n @pagoacredito = Pagoacredito.find(params[:id])\n @pagoacredito.destroy\n\n respond_to do |format|\n format.html { redirect_to pagoacreditos_url }\n #format.json { head :ok }\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 @permiso.destroy\n respond_to do |format|\n format.html { redirect_to permisos_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 @usuario_perfil = UsuarioPerfil.find(params[:id])\n @usuario_perfil.destroy\n\n respond_to do |format|\n format.html { redirect_to usuario_perfils_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @perfisusuario.destroy\n respond_to do |format|\n format.html { redirect_to perfisusuarios_url, notice: 'Perfil de Usuário excluído com sucesso.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @perfilnegocio = Perfilnegocio.find(params[:id])\n @perfilnegocio.destroy\n\n respond_to do |format|\n format.html { redirect_to perfilnegocios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @permiso = Permiso.find(params[:id])\n @permiso.destroy\n\n respond_to do |format|\n format.html { redirect_to permisos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @basico_persona_juridica.destroy\n respond_to do |format|\n format.html { redirect_to basico_persona_juridicas_url, notice: 'Persona juridica was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @analise_privacidade.destroy\n respond_to do |format|\n format.html { redirect_to analise_privacidades_url, notice: 'Analise privacidade was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @presencia = Presencia.find(params[:id])\n @presencia.destroy\n\n respond_to do |format|\n format.html { redirect_to presencia_url }\n format.json { head :ok }\n end\n end",
"def destroy\n\t\tauthorize! :destroy, HistorialEstadoPresupuesto\n @historial_estado_presupuesto.destroy\n respond_to do |format|\n format.html { redirect_to historial_estado_presupuestos_url, notice: 'Historial estado presupuesto fue borrado satisfactoriamente.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @permiso.destroy\n respond_to do |format|\n format.html { redirect_to permisos_url, notice: 'Permiso fue eliminado.' }\n format.json { head :no_content }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
checks the album to see if there is a file with the same def has_same_photo?(album_id, f)
|
def has_same_photo?(fb_photos, f)
# album = Mogli::Album.find(album_id, client)
# fb_photos = album.photos
has_photo = false
fb_photos.each do |p|
break if has_photo
fb_photo_url = p.source
fb_photo_file = get_photo_as_file_from_url(fb_photo_url)
# Rails.logger.info "reference photo(from flickr): #{f.path} - exists? #{File.exists?(f.path)}"
# Rails.logger.info "compared to (from fb): #{fb_photo_file.path} - exists? #{File.exists?(fb_photo_file.path)}"
# Delayed::Worker.info "reference photo(from flickr): #{f.path} - exists? #{File.exists?(f.path)}"
# Delayed::Worker.logger.info "comparing incoming flickr photo to fb photos: #{fb_photo_file.path} - exists? #{File.exists?(fb_photo_file.path)}"
Delayed::Worker.logger.info "comparing incoming flickr photo to fb photos: #{p.name} - #{fb_photo_url}"
comparer = ImageCompare.new(f.path, fb_photo_file.path)
has_photo = true if comparer.identical?(:tolerance => 0.02)
Delayed::Worker.logger.info "identical to flickr photo?: #{has_photo.inspect}"
end
Delayed::Worker.logger.info " ********** Found duplicate in album?: #{has_photo.inspect}"
Delayed::Worker.logger.info " "
return has_photo
end
|
[
"def photo_exist?(photo) \n\t### \n\t# compare sha of photo with the sha tag of EVERY photo that we've\n\t# already uploaded. \n\t# \thow do we do that? \n\t# \t\t \n\t# return true if that sha already exits as a tag. \n\t# return false if it dunna. \n\tsha = checksum_photo(photo) \n\t####\n\t# \t\nend",
"def has_photo?\n File.exists? photo_filename\n end",
"def has_photo?\n \tFile.exists? photo_filename\n end",
"def all_same_album?(tags)\n all_same_tag?(tags, :album)\n end",
"def identical?(file1, file2)\n size(file1) == size(file2) && md5(file1) == md5(file2)\n end",
"def identical?(file1, file2)\n size(file1) == size(file2) && md5(file1) == md5(file2)\n end",
"def photo_exists?(event)\n (!event.photo_file_name.nil? && !event.photo_file_name.empty?) || (event.photo_content_type && event.photo_file_size)\n end",
"def no_duplicate_photos\n Photo.where(\"user_id = ? AND photo_file_name = ? AND time = ? AND photo_file_size = ?\", self.user_id, self.photo_file_name, self.time, self.photo_file_size).each do |photo|\n if((self.id.nil? ) && ((self.title.blank? && self.caption.blank?) || self.title == photo.title))\n errors.add(:photo_file_name, \"There is already a photo submitted by you with the same filename and time. To submit the same photo twice you need to at least give it a unique filename.\")\n end\n end\n end",
"def identical?(file1, file2)\n inode(file1) == inode(file2)\n end",
"def files_are_same(file1, file2)\n begin\n File.open(file1, 'rb').read == File.open(file1, 'rb').read\n rescue\n false\n end\nend",
"def has_photo?\n ! Photo.find_by_person_id(self.id, :select=>'id').nil?\n end",
"def album_unique?(album_object, artist_object)\n\n albums = self.albums.select{|album| album.artist.present?}\n non_nil_albums = albums.select{|album| album.artist.name == artist_object.name} << album_object.name\n non_nil_albums.length == non_nil_albums.uniq.length\n end",
"def same_size_as?(other_file)\n @file_size && @file_size == other_file.file_size ? true : false\n end",
"def same_file?(a, b)\n File.expand_path(a) == File.expand_path(b)\n end",
"def set_mix_or_album\n self.is_mix = self.tracks.any?{ |track| track.asset.user.id.to_s != self.user.id.to_s}\n true\n end",
"def photoset_exist? name\n @flickr.photosets.getList.each do |x|\n return true if x.title == name\n end\n return false\n end",
"def identical_in_container\n container.stored_files.where(file_name: file_name,\n path: path,\n file_hash: file_hash).first\n end",
"def same_files?(local_path, remote_path)\n result = false\n unless @ssh.nil?\n remote_md5 = @ssh.exec!(md5_command_line(remote_path))\n local_md5 = `#{md5_command_line(local_path)}`\n @logger.debug { \"same_files? local_md5 => #{local_md5}, remote_md5 => #{remote_md5}\"}\n result = (remote_md5 == local_md5)\n end\n result\n end",
"def check_album artist, album, paths\n changes = {}\n\n # if this is a new album\n unless $library[artist].include? album\n # look for similar existing album names\n STDERR.puts \"New album: #{album}\"\n distances = $library[artist].map { |a| [a, edit_distance(a || '', album || '')] }\n min = distances.min_by(&:last)\n matches = distances.select { |a, d| d == min[1] }.map(&:first)\n\n unless matches.empty?\n STDERR.puts \"Closest matches:\"\n matches.each { |a| puts \"\\t#{a}\" }\n end\n # prompt for new one\n STDERR.print \"Change album name? \"\n new = STDIN.gets.strip\n\n # if new name set\n if not new.empty? and new != album\n album = new\n\n # update songs\n paths.each do |path|\n changes[path] = album\n end\n end\n end\n\n if $library[artist].include? album\n STDOUT.puts \"ERROR: CONFLICT: Duplicate album: #{album}\"\n paths.each { |path| STDOUT.puts \"ERROR: SRC: #{path}\" }\n Find.find(dest(artist, album)) { |path| STDOUT.puts \"ERROR: DST: #{path}\" unless File.directory? path }\n return [nil, changes]\n end\n\n $library[artist] << album\n return [album, changes]\nend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
A group is not destroyed, it's disbanded!
|
def disband_group
destroy_collection({:table=>'groups', :on_success=>'You disbanded the group.'})
rescue
flash[:notice] = "Could not find group."
redirect_to :action=>'groups'
end
|
[
"def dissolve_groups\n groups.destroy_all\n end",
"def ungroup\n send_transport_message('BecomeCoordinatorOfStandaloneGroup')\n end",
"def delete_group(group)\n\t\t\tend",
"def remove_group!( group )\n save if remove_group( group )\n end",
"def remove_group\n create_group.tap do |r|\n r.action(:remove)\n end\n end",
"def destroy\n Group.rebuild! if nil.|Group.find(:first).rgt\n\t @group = Group.find(params[:id])\n @group.destroy\n\n respond_to do |format|\n format.html { redirect_to(groups_url) }\n format.xml { head :ok }\n end\n end",
"def remove(group)\r\n @groupList.delete(group)\r\n end",
"def remove_from_group(group)\n self.memberships.find_by(group_id: group.id).destroy!\n end",
"def disown!(group)\n return if group.class != Group\n e = Entity.find_by(id: self.id)\n return if e.nil?\n relationship = EntityGroupRelationship.find_by(entity_id: self.id, group_id: group.id)\n return if relationship.nil?\n if relationship.position.nil?\n return relationship.destroy\n end\n index = relationship.position\n relationship.destroy\n # self.update_position(index)\n end",
"def on_tag_group_destroy( node, tag_group )\n\t\t\tself.log.debug \"unhandled on_tag_group_destroy: node %p no longer has tag group %p\" %\n\t\t\t \t[ node, tag_group ]\n\t\tend",
"def leave()\n\t\treturn if !@group\n\t\tcpg_name = Corosync::CpgName.new\n\t\tcpg_name[:value] = @group\n\t\tcpg_name[:length] = @group.size\n\n\t\t# we can't join multiple groups, so I dont know why corosync requires you to specify the group name\n\t\tCorosync.cs_send(:cpg_leave, @handle, cpg_name)\n\n\t\t@group = nil\n\tend",
"def delete_related_groups\n \n end",
"def reset_group_membership\n shell_out!(\"group\", \"mod\", \"-n\", \"#{new_resource.group_name}_bak\", new_resource.group_name)\n\n shell_out!(\"group\", \"add\", set_options(overwrite_gid: true))\n\n shell_out!(\"group\", \"del\", \"#{new_resource.group_name}_bak\")\n end",
"def destroy\n \tcurrent_user.update(:user_group => nil)\n\t\tredirect_to '/user_groups', :notice => \"You have left #{UserGroup.find_by_group_name(params[:id]).group_name}\"\n end",
"def delete_all_groups\n super\n end",
"def remove_from_group\n Group.find(self.parentID).remove_members([self.id.to_s])\n end",
"def remove_from_group\n new_group_owner = group_members.earliest\n if new_group_owner.present?\n new_group_owner.update(group_owner_id: nil)\n group_members.update_all(group_owner_id: new_group_owner.id)\n end\n new_group_owner\n end",
"def destroy\n \n @group = Group.find(params[:id])\n @game = @group.jigsaw\n \n @group.destroy\n\n redirect_to game_groups_path(@game), notice: 'Grupo eliminado correctamente' \n \n end",
"def remove_from_group\n asset_group = AssetGroup.find_by_object_key(params[:asset_group])\n if asset_group.nil?\n notify_user(:alert, \"Can't find the asset group selected.\")\n else\n if @asset.asset_groups.exists? asset_group.id\n @asset.asset_groups.delete asset_group\n notify_user(:notice, \"Asset #{@asset} was removed from '#{asset_group}'.\")\n else\n notify_user(:alert, \"Asset #{@asset} is not a member of '#{asset_group}'.\")\n end\n end\n\n # Always display the last view\n redirect_back(fallback_location: root_path)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
GET /room_plants GET /room_plants.json
|
def index
@room_plants = RoomPlant.all
end
|
[
"def index\n \n @plants = Plant.all\n @personal_plants = PersonalPlant.where(:user_id => session[:user][:id])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @plants }\n end\n end",
"def show\n @people_by_room = PeopleByRoom.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @people_by_room }\n end\n end",
"def index\n @plants = Plant.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @plants }\n end\n end",
"def findRoom\n\t\t@room = @tutorial.room\n\t\trender json: @room\n\tend",
"def index\n @plants = @garden.plants\n end",
"def index\n @people_by_rooms = PeopleByRoom.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @people_by_rooms }\n end\n end",
"def index\n @room = Room.find(params[:room_id])\n @avaibilities = @room.avaibilities\n end",
"def index\n @requests_rooms = RequestsRoom.all\n render json: @requests_rooms\n\n end",
"def show\n @poem = Poem.find(params[:id])\n # render json: @poems\n end",
"def show\n @type_room = TypeRoom.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @type_room }\n end\n end",
"def show\n @restroom = Restroom.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @restroom }\n end\n end",
"def new\n @people_by_room = PeopleByRoom.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @people_by_room }\n end\n end",
"def index\n rooms = Array.new\n if params[:facility].nil?\n # 自分の施設情報だけを返す\n facilities = current_user.facilities\n facilities.each do |facility|\n rooms.concat(facility.rooms)\n end\n else\n # facility=[facility_id]\n facility = Facility.find_by(id: params[:facility].to_i)\n # 施設IDが存在しない場合\n if facility.nil?\n response = {\n status: 'NotFound',\n message: 'rooms not found'\n }\n return render json: response, status: 404\n end\n # ユーザーの施設IDでない場合\n if facility.user_id != current_user.id\n response = {\n status: 'NotFound',\n message: 'rooms not found'\n }\n return render json: response, status: 404\n end\n rooms.concat(facility.rooms)\n end\n\n render json: {\n status: 'Success',\n message: '',\n rooms: rooms.as_json(except: [\n :created_at,\n :updated_at\n ], include: [\n :ota_rooms\n ])\n }, status: 200\n end",
"def show\n render json: @room_user\n end",
"def show\n @room_type = RoomType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @room_type }\n end\n end",
"def index\n @political_parties = PoliticalParty.all\n end",
"def index\n rooms = Room.includes(:problems, :registrations, :users, :owner)\n if params[:name]\n render json: rooms.where(name: params[:name])\n else\n render json: rooms\n end\n end",
"def show\n\t\trender json: @room_user\n\tend",
"def index\n respond_to do |format|\n\n @plants = Plant.order('lower(name) ASC').paginate(page: params[:page])\n format.html { render :html => @plants } # index.html.erb\n if params[:page].present?\n @jsonPlants = Plant.order('lower(name) ASC').paginate(page: params[:page], per_page: params[:per_page])\n else\n @jsonPlants = Plant.all\n end\n\n @jsonPlantsDub = [:Plant]\n\n if params[:name].present?\n @jsonPlants.each do |p|\n if !p.name.downcase.include?(params[:name].downcase)\n @jsonPlantsDub << p\n end\n end\n end\n\n @jsonPlants -= @jsonPlantsDub\n format.json { render :json => {admin: admin?, count: @plants.total_entries, plants: @jsonPlants} }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
POST /room_plants POST /room_plants.json
|
def create
@room_plant = RoomPlant.new(room_plant_params)
if @room_plant.save
render :show, status: :created, location: @room_plant
else
render json: @room_plant.errors, status: :unprocessable_entity
end
end
|
[
"def create\n plant = Plant.create(plant_params)\n render json: plant, status: :created\n end",
"def create\n @room = Room.new(params[:room])\n\n if @room.save\n render :json => @room, :status => :created, :location => @room\n else\n render :json => @room.errors, :status => :unprocessable_entity\n end\n end",
"def create\n @requests_room = RequestsRoom.new(requests_room_params)\n\n if @requests_room.save\n render json: @requests_room, status: :created, location: @requests_room\n\n else\n render json: @requests_room.errors.full_messages , status: :unprocessable_entity\n\n end\n\n end",
"def create\n @room = Room.new(room_params)\n\n respond_to do |format|\n if @room.save\n format.html { redirect_to @room, notice: 'Room was successfully created.' }\n format.json { render :show, status: :created, location: @rooms }\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 @plant = @garden.plants.build(plant_params)\n\n respond_to do |format|\n if @plant.save\n format.html { redirect_to garden_plants_path(@garden), notice: 'Plant was successfully created.' }\n format.json { render :show, status: :created, location: @plant }\n else\n format.html { render :new }\n format.json { render json: @plant.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @type_room = TypeRoom.new(params[:type_room])\n\n respond_to do |format|\n if @type_room.save\n format.html { redirect_to @type_room, notice: 'Type room was successfully created.' }\n format.json { render json: @type_room, status: :created, location: @type_room }\n else\n format.html { render action: \"new\" }\n format.json { render json: @type_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @plant = @garden.plants.new(plant_params)\n\n respond_to do |format|\n if @plant.save\n format.html { redirect_to garden_plant_path(@garden, @plant), notice: 'Plant was successfully created.' }\n format.json { render action: 'show', status: :created, location: @plant }\n else\n format.html { render action: 'new' }\n format.json { render json: @plant.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @room_petition = RoomPetition.new(room_petition_params)\n\n respond_to do |format|\n if @room_petition.save\n format.html { redirect_to @room_petition, notice: 'Room petition was successfully created.' }\n format.json { render :show, status: :created, location: @room_petition }\n else\n format.html { render :new }\n format.json { render json: @room_petition.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @user=User.find(params[:user_id])\n @room = @user.rooms.create(room_params)\n if @room.save\n render json: @room, status: :created\n else\n render json: @room.errors, status: :unprocessable_entity\n end\n end",
"def create\n @reserved_room = ReservedRoom.new(reserved_room_params)\n\n respond_to do |format|\n if @reserved_room.save\n format.html { redirect_to @reserved_room, notice: 'Reserved room was successfully created.' }\n format.json { render :show, status: :created, location: @reserved_room }\n else\n format.html { render :new }\n format.json { render json: @reserved_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @restroom = Restroom.new(restroom_params)\n\n respond_to do |format|\n if @restroom.save\n format.html { redirect_to @restroom, notice: 'Restroom was successfully created.' }\n format.json { render action: 'show', status: :created, location: @restroom }\n else\n format.html { render action: 'new' }\n format.json { render json: @restroom.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @livingroom = Livingroom.new(livingroom_params)\n\n respond_to do |format|\n if @livingroom.save\n format.html { redirect_to @livingroom, notice: 'Livingroom was successfully created.' }\n format.json { render :show, status: :created, location: @livingroom }\n else\n format.html { render :new }\n format.json { render json: @livingroom.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 @apartment = Apartment.all\n # binding.pry\n @masters_chatroom_apartment = ChatroomApartment.new(masters_chatroom_apartment_params)\n # apa = @apartment.@masters_chatroom_apartment.apartment_id.room_num\n binding.pry\n respond_to do |format|\n if @masters_chatroom_apartment.save\n format.html { redirect_to [:masters,@masters_chatroom_apartment], notice: 'Chatroom apartment was successfully created.' }\n format.json { render :show, status: :created, location: @masters_chatroom_apartment }\n else\n format.html { render :new }\n format.json { render json: @masters_chatroom_apartment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n begin\n url = URI(\"https://bookinn.ngrok.io/rooms\")\n\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n request = Net::HTTP::Post.new(url)\n request[\"Authorization\"] = \"Bearer #{session[\"access_token\"]}\"\n request[\"Content-Type\"] = \"application/json\"\n request.body = room_params.to_json\n response = http.request(request)\n puts response.read_body\n\n @response_json = JSON.parse(response.read_body)\n rescue => exception\n redirect_to new_room_path\n else\n if @response_json[\"status\"] == 200\n redirect_to new_room_path\n elsif @response_json[\"status\"] == 401\n redirect_to login_path\n else\n redirect_to new_room_path\n end\n end\n end",
"def create\n @room_type = RoomType.new(room_type_params)\n\n respond_to do |format|\n if @room_type.save\n format.html { redirect_to @room_type, notice: 'Room type was successfully created.' }\n format.json { render :show, status: :created, location: @room_type }\n else\n format.html { render :new }\n format.json { render json: @room_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @room_type = RoomType.new(params[:room_type])\n\n respond_to do |format|\n if @room_type.save\n format.html { redirect_to room_types_path, notice: \"#{I18n.t \"html.save_success\"}\" }\n format.json { render json: @room_type, status: :created, location: @room_type }\n else\n format.html { render action: \"new\" }\n format.json { render json: @room_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @roomrentalmanager = Roomrentalmanager.new(roomrentalmanager_params)\n\n respond_to do |format|\n if @roomrentalmanager.save\n format.html { redirect_to @roomrentalmanager, notice: 'Roomrentalmanager was successfully created.' }\n format.json { render :show, status: :created, location: @roomrentalmanager }\n else\n format.html { render :new }\n format.json { render json: @roomrentalmanager.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @peel = Peel.new(peel_params)\n\n respond_to do |format|\n if @peel.save\n format.html { redirect_to @peel, notice: 'Peel was successfully created.' }\n format.json { render :show, status: :created, location: @peel }\n else\n format.html { render :new }\n format.json { render json: @peel.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
PATCH/PUT /room_plants/1 PATCH/PUT /room_plants/1.json
|
def update
if @room_plant.update(room_plant_params)
render :show, status: :ok, location: @room_plant
else
render json: @room_plant.errors, status: :unprocessable_entity
end
end
|
[
"def update\n @people_by_room = PeopleByRoom.find(params[:id])\n\n respond_to do |format|\n if @people_by_room.update_attributes(params[:people_by_room])\n format.html { redirect_to @people_by_room, notice: 'People by room was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @people_by_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @room = Room.find(params[:id])\n\n if @room.update_attributes(params[:room])\n head :ok\n else\n render :json => @room.errors, :status => :unprocessable_entity \n end\n end",
"def update\n @restroom = Restroom.find(params[:id])\n authorize @restroom\n\n respond_to do |format|\n if @restroom.update_attributes(params[:restroom])\n format.html { redirect_to @restroom, notice: 'Restroom was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @restroom.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @request_room = RequestRoom.find(params[:id])\n\n respond_to do |format|\n if @request_room.update_attributes(params[:request_room])\n format.html { redirect_to @request_room, notice: 'Request room was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @request_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @restroom.update(restroom_params)\n format.html { redirect_to @restroom, notice: 'Restroom was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @restroom.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @restroom = Restroom.find(params[:id])\n authorize! :update, @restroom\n\n respond_to do |format|\n if @restroom.update_attributes(params[:restroom])\n format.html { redirect_to @restroom, notice: 'Restroom was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @restroom.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @requests_room.update(requests_room_params)\n render json: @requests_room\n\n else\n render json: @requests_room.errors, status: :unprocessable_entity\n\n end\n end",
"def update\n if @room.update(room_params)\n render json: @room, status: :ok, serializer: RoomSerializer\n else\n render json: @room.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @request_room.update(request_room_params)\n format.html { redirect_to @request_room, notice: 'Request room was successfully updated.' }\n format.json { render :show, status: :ok, location: @request_room }\n else\n format.html { render :edit }\n format.json { render json: @request_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @type_room = TypeRoom.find(params[:id])\n\n respond_to do |format|\n if @type_room.update_attributes(params[:type_room])\n format.html { redirect_to @type_room, notice: 'Type room was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @type_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lectroom = Lectroom.find(params[:id])\n\n respond_to do |format|\n if @lectroom.update_attributes(params[:lectroom])\n format.html { redirect_to @lectroom, :notice => 'Аудитория успешно обновлена' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @lectroom.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @type_of_room.update(type_of_room_params)\n format.html { redirect_to @type_of_room, notice: 'Type of room was successfully updated.' }\n format.json { render :show, status: :ok, location: @type_of_room }\n else\n format.html { render :edit }\n format.json { render json: @type_of_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @serverroom = Serverroom.find(params[:id])\n\n respond_to do |format|\n if @serverroom.update_attributes(params[:serverroom])\n format.html { redirect_to @serverroom, notice: 'Serverroom was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @serverroom.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @kato_room.update(kato_room_params)\n format.html { redirect_to @kato_room, notice: 'Kato room was successfully updated.' }\n format.json { render :show, status: :ok, location: @kato_room }\n else\n format.html { render :edit }\n format.json { render json: @kato_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @plat = Plat.find(params[:id])\n\n respond_to do |format|\n if @plat.update_attributes(params[:plat])\n format.html { redirect_to @plat, notice: 'Plat was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @plat.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @room_petition.update(room_petition_params)\n format.html { redirect_to @room_petition, notice: 'Room petition was successfully updated.' }\n format.json { render :show, status: :ok, location: @room_petition }\n else\n format.html { render :edit }\n format.json { render json: @room_petition.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @roomslot = Roomslot.find(params[:id], :readonly => false)\n\n respond_to do |format|\n if @roomslot.update_attributes(params[:roomslot])\n format.html { redirect_to timeslots_url}\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @roomslot.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @admin_room.update(admin_room_params)\n format.html { redirect_to admin_rooms_path, notice: 'Room was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @admin_room.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @potluck.update(potluck_params)\n format.json { render :show, status: :ok, location: @potluck }\n else\n format.json { render json: @potluck.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
DELETE /room_plants/1 DELETE /room_plants/1.json
|
def destroy
@room_plant.destroy
end
|
[
"def destroy\n @path_of_plant.destroy\n respond_to do |format|\n format.html { redirect_to path_of_plants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admin_roommate.destroy\n respond_to do |format|\n format.html { redirect_to admin_rooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @plant = Plant.find(params[:id])\n @plant.destroy\n\n respond_to do |format|\n format.html { redirect_to plants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @restroom.destroy\n respond_to do |format|\n format.html { redirect_to restrooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admin_room.destroy\n respond_to do |format|\n format.html { redirect_to admin_rooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @plant = @garden.plants.find(params[:id])\n @plant.destroy\n respond_to do |format|\n format.html { redirect_to @garden, notice: 'Plant deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @people_by_room = PeopleByRoom.find(params[:id])\n @people_by_room.destroy\n\n respond_to do |format|\n format.html { redirect_to people_by_rooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @room = Room.find(params[:id])\n @room.destroy\n render json: {:success => true, :message=> \"Room has been deleted successfully\"}, status: 201\n end",
"def destroy\n @type_room = TypeRoom.find(params[:id])\n @type_room.destroy\n\n respond_to do |format|\n format.html { redirect_to type_rooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @room = Room.find(params[:id])\n @room.destroy\n\n respond_to do |format|\n format.html { redirect_to rooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bathroom = Bathroom.find(params[:id])\n @bathroom.destroy\n\n respond_to do |format|\n format.html { redirect_to bathrooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @room = Room.find(params[:id])\n @room.destroy\n\n respond_to do |format|\n format.html { redirect_to rooms_url }\n format.json { head :ok }\n end\n end",
"def destroy\n if not check_logged_in then\n return\n end\n @plant = Plant.find(params[:id])\n @plant.destroy\n\n respond_to do |format|\n format.html { redirect_to plants_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @press_room.destroy\n respond_to do |format|\n format.html { redirect_to press_rooms_url, notice: 'Press room was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @restroom = Restroom.find(params[:id])\n authorize @restroom\n @restroom.destroy\n respond_to do |format|\n format.html { redirect_to restrooms_path, notice: 'Restroom deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @serverroom = Serverroom.find(params[:id])\n @serverroom.destroy\n\n respond_to do |format|\n format.html { redirect_to serverrooms_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @room_type = RoomType.find(params[:id])\n @room_type.destroy\n\n respond_to do |format|\n format.html { redirect_to room_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hostel_room = HostelRoom.find(params[:id])\n @hostel_room.destroy\n\n respond_to do |format|\n format.html { redirect_to hostel_rooms_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @lectroom = Lectroom.find(params[:id])\n @lectroom.destroy\n\n respond_to do |format|\n format.html { redirect_to lectrooms_url }\n format.json { head :ok }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
get the active tasks
|
def active_tasks
request.method = :get
request.uri = '_active_tasks'
Couchdbtools.execute(request)
end
|
[
"def active_tasks\n @tasks.select { | task | task.active }\n end",
"def active_tasks\n @tasks.where( :active => true )\n end",
"def available_tasks\n return @db.filter {|task| task.user_id == @current_user_id}\n end",
"def tasks\n return @tasks\n end",
"def inactive_tasks\n @tasks.where( :active => false )\n end",
"def inactive_tasks\n @tasks.select { | task | ! task.active }\n end",
"def get_available_tasks\n tasks_to_return = []\n @tasks_names.each{ |t_name|\n tasks_to_return.push(@tasks[t_name])\n } \n return tasks_to_return\n end",
"def tasks\n @task_manager.tasks_in_scope(@scope)\n end",
"def tasks\n Thread.current[:celluloid_actor].tasks.to_a\n end",
"def tasks\n @tasks ||= Evoke.tasks\n end",
"def getTasklist\r\n\t\t\t\t\treturn @tasklist\r\n\t\t\t\tend",
"def completed_tasks\n @tasklist.select { |value| value.status == 'done' }\n end",
"def all_tasks\n @task = Task.get_all_tasks_user_can_see(current_user)\n end",
"def current_task_names\n login\n TaskDefinitionsPage.new(browser, base_url).tasks_options\n end",
"def get_tasks\n res = ODPS.conn.get \"projects/#{ODPS.current_project}/instances/#{self.name}?taskstatus\"\n tasks = []\n REXML::XPath.each(REXML::Document.new(res.body), '/Instance/Tasks/Task') do |element|\n case element.attribute('Type').value\n when 'SQL'\n tasks << SQLTask.new.deserialize(element)\n when 'SQLPlan'\n tasks << SQLPlanTask.new.deserialize(element)\n else\n AliODPS::LOGGER.warn \"Unknown task type: #{element.attribute('Type').value}\"\n end\n end\n tasks\n end",
"def tasks\n nodes\n end",
"def tasks\n Easybill::Api::Tasks\n end",
"def tasks\n @client.list_tasks(cluster: @cluster, service_name: @name)[0]\n end",
"def tasks\n @tasks ||= Thor::CoreExt::OrderedHash.new\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Sets the base url for this class. Note that it will not be inherited by subclasses.
|
def set_base_url(url)
base_url = url
end
|
[
"def base_url=(url)\n @base_url = url\n end",
"def base_url=(val)\n @base_url = val\n end",
"def base_url\n @base_url || self.class.base_url\n end",
"def with_base_url(base_url)\n @url_prefix = base_url\n self\n end",
"def base_url\n @base_url || DEFAULT_BASE_URL\n end",
"def initialize base_url\n @base_url = base_url\n end",
"def base_urls=(value)\n @base_urls = value\n end",
"def base_uri(value)\n @config[:base_uri] = value\n end",
"def base_file_url=(new_base_url)\n @base_file_url = base_for(new_base_url)\n end",
"def SetBaseSearchURL(new_base_url)\n if new_base_url == \"\" || new_base_url == nil\n Builtins.y2error(\"Wrong base URL: '%1'\", new_base_url)\n return\n end\n\n @base_url = new_base_url\n Builtins.y2milestone(\"New base URL has been set: %1\", @base_url)\n\n nil\n end",
"def reset_base_uri\n @base_uri = self.class.send(:default_base_uri)\n end",
"def base_uri=(base_uri)\n default_application.base_uri = base_uri\n end",
"def base_url\n @base_url || value('base_url')\n end",
"def url(url)\n self.default_url = url\n end",
"def api_base_url=(url)\n version = Apipie.configuration.default_version\n @api_base_url[version] = url\n end",
"def base_url\n context[:base_url] || '/'\n end",
"def base=(new_base)\n @base = Addressable::URI.parse(new_base)\n self.resources.each do |resource|\n resource.base = @base\n end\n self.methods.each do |method|\n method.base = @base\n end\n end",
"def base_uri=(uri)\n @base ||= head.add_child(Elements::Basic.new('base', self))\n @base['href'] = uri\n end",
"def base_url\n context[:base_url] || \"/\"\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Builds a new HTTP request and adds it to the +Config.hydra+ request queue. Registers a callback that invokes +handle_response+ when the request completes. Recognizes the following options: +headers+ a hash to add or update the request headers +timeout+ the timeout for the request (defaults to +Ladon.default_request_timeout+) +default_data+ passes this on to +handle_response+
|
def queue_request(url_or_path, options = {}, &block)
url = absolute_url(url_or_path)
headers = {:Accept => MEDIA_TYPE_JSON}.merge(options.fetch(:headers, {}))
headers = merge_log_weasel_header(headers)
timeout = options.fetch(:timeout, Ladon.default_request_timeout)
request = Typhoeus::Request.new(url, headers: headers, timeout: timeout)
request.on_complete do |response|
handle_response(response, request: request, default_data: options[:default_data], &block)
end
Ladon.hydra.queue(request)
end
|
[
"def do_request req, options={}\n Log.debug RequestLogSeperator\n Log.debug \"#{req.class} #{req.path}\"\n Log.debug \"HEADERS: #{req.to_hash}\"\n Log.debug \"BODY:\\n#{req.body}\" if req.request_body_permitted?\n\n if options.has_key? :timeout\n cur_timeout = @http.read_timeout\n Log.debug \"Overriding timeout to: #{options[:timeout]}\"\n @http.read_timeout = options[:timeout]\n end\n\n response = @http.request(req)\n\n if cur_timeout\n @http.read_timeout = cur_timeout\n end\n\n Log.debug \"RESPONSE CODE: #{response.code}\"\n Log.debug \"RESPONSE HEADERS: #{response.to_hash}\"\n Log.debug \"RESPONSE BODY:\\n#{jsonify response.body}\\n\"\n\n @last_request = req\n @last_response = response\n\n raise RequestException.new(req, response) unless response.kind_of? Net::HTTPSuccess\n\n objectify response.body\n end",
"def process!\n @start = Time.now\n http = EventMachine::HttpRequest.new(url,\n connect_timeout: timeout,\n inactivity_timeout: timeout,\n )\n\n @request = http.public_send(method,\n request_options\n )\n\n @request.callback { @completed = true; @runtime = Time.now - @start; @start = nil }\n @request.errback { @completed = @error = true; @runtime = Time.now - @start; @start = nil}\n self\n end",
"def build_request\n\n uri = URI.parse(@endpoint)\n # add uri\n params = [uri.host, uri.port]\n # add proxy\n params += @proxy.values_at(:host, :port, :user, :pass) unless @proxy.empty?\n\n @http = Net::HTTP.new(*params)\n # add ssl\n if @endpoint.start_with?('https')\n @http.use_ssl = true\n @http.verify_mode = OpenSSL::SSL::VERIFY_PEER\n end\n\n net_http = Kernel.const_get('Net::HTTP::' + @request_method[:method].capitalize)\n @request = add_request_headers(net_http.new(uri.request_uri))\n\n end",
"def make_request\n response = @http.request(@request)\n end",
"def initialize(requests=[], handler_proc=nil, options={}, &block)\n handler_proc = block if block_given?\n handler_proc ||= default_handler_proc\n \n initialize_options(options)\n \n params = build_params(options)\n \n io_reactor = DefaultConnectingIOReactor.new(2, params);\n \n httpproc = BasicHttpProcessor.new;\n httpproc.add_interceptor(RequestContent.new);\n httpproc.add_interceptor(RequestTargetHost.new);\n httpproc.add_interceptor(RequestConnControl.new);\n httpproc.add_interceptor(RequestUserAgent.new);\n httpproc.add_interceptor(RequestExpectContinue.new);\n \n # We are going to use this object to synchronize between the \n # I/O event and main threads\n request_counter = java.util.concurrent.CountDownLatch.new(requests.length);\n\n handler = BufferingHttpClientHandler.new(\n httpproc,\n RequestExecutionHandler.new(request_counter, handler_proc),\n org.apache.http.impl.DefaultConnectionReuseStrategy.new,\n params\n )\n \n handler.event_listener = options[:event_listener].new if options[:event_listener]\n \n io_event_dispatch = DefaultClientIOEventDispatch.new(handler, params)\n\n Thread.abort_on_exception = true\n t = Thread.new do\n begin\n #puts \"Executing IO reactor\"\n io_reactor.execute(io_event_dispatch)\n rescue java.io.InterruptedIOException => e\n puts \"Interrupted\"\n rescue java.io.IOException => e\n puts \"I/O error in reactor execution thread: #{e.message}\"\n end\n #puts \"Shutdown\"\n end\n \n process_requests(requests, io_reactor, request_counter)\n \n # Block until all connections signal\n # completion of the request execution\n request_counter.await()\n\n #puts \"Shutting down I/O reactor\"\n\n io_reactor.shutdown()\n\n #puts \"Done\"\n end",
"def hoclet_request method, path, content, &block\n\n # get configuration\n host = Hoccer.config[\"hoclet_host\"]\n port = Hoccer.config[\"hoclet_port\"]\n\n # bail out if hoclets are disabled\n if host.nil? || host == \"\" || port.nil? || port == \"\"\n puts \"ignoring hoclet transaction: not configured\"\n return\n end\n\n # compose request to hoclet server\n http = EM::Protocols::HttpClient.request(\n :host => host,\n :port => port,\n :verb => method ||= \"POST\",\n :request => path ||= \"/\",\n :content => content\n )\n\n # log the request\n puts \"request to hoclet server: #{http.method} #{http.request} #{http.content}\"\n\n # when done...\n http.callback do |response|\n\n # log the response\n code = response[:code]\n content = response[:content]\n puts \"response from hoclet server: #{code} #{content}\"\n\n # call back if required\n unless block.nil?\n block.call( response )\n end\n end\nend",
"def _make_request(method, url, data, headers = nil) \n # update headers with default value\n headers = {} unless headers\n headers.update @headers\n \n if @debug\n puts \"-----------------------------------\"\n puts \"Make #{method} request to #{url}\"\n puts \"Headers\"\n headers.each do |key, value|\n puts \" #{key}: #{value}\"\n end\n puts \"Payload\"\n data.each do |key, value|\n puts \" #{key}: #{value}\"\n end\n puts \"-----------------------------------\"\n end \n\n # make request\n case method\n when \"GET\" then @client.get url, headers\n when \"POST\" then @client.post url, data, headers\n when \"PUT\" then @client.put url, headers\n when \"DELETE\" then @client.delete url, headers\n end\n end",
"def create_new_http_request\n # Create a new HTTP request instance\n request_spec = @data[:request][:instance]\n http_class = \"Net::HTTP::#{request_spec.verb._camelize}\"\n http_request = http_class._constantize::new(request_spec.path)\n # Set the request body\n if request_spec.is_io?\n http_request.body_stream = request_spec.body\n else\n http_request.body = request_spec.body\n end\n # Copy headers\n request_spec.headers.each { |header, value| http_request[header] = value }\n # Save the new request\n request_spec.raw = http_request\n # Set user-agent\n if @data[:options].has_key?(:connection_user_agent)\n http_request['user-agent'] ||= @data[:options][:connection_user_agent]\n end\n http_request\n end",
"def initialize host, timeout=5, content_type='application/json;charset=utf-8'\n\t\t\t@host = host\n\t\t\t@default_type = content_type\n\t\t\t@default_timeout = timeout\n\t\t\t@request_queue = {}\n\t\tend",
"def build_http_request(request={})\n EM::HttpRequest.new(request[:url]).send(request[:action], request[:opts])\n\n # The above line replaces the need for the following\n # DO NOT DELETE\n #case request[:action]\n #when :get\n # EM::HttpRequest.new(request[:url]).get(head: request[:opts])\n #when :post\n # EM::HttpRequest.new(request[:url]).post(head: request[:opts])\n #end\n\n end",
"def request_handler\n -> { run(@scheduler.request_queue, nil, RequestHandler.new) }\n end",
"def http(request_opts = nil)\n request_opts ||= RequestOptions.new\n timeout = request_opts.http_timeout || @http_timeout\n bearer_token = request_opts.not_authorized ? nil : get_bearer_token\n @http_class.new(@addr, @port, timeout, bearer_token, request_opts)\n end",
"def with_logging\n log_request http.url, http.headers, http.body\n response = yield\n log_response response.code, response.body\n response\n end",
"def sendPostRequest(username, password,\n path, request_ressource,\n response_handler, query_params)\n\n uri = URI.parse(@base_url+path);\n\n request = Net::HTTP::Post.new(uri.path)\n\n request.basic_auth(username, password)\n request[\"Content-Type\"] = \"application/json\"\n request[\"Accept\"] = \"application/json\"\n\n generated_json = request_ressource.to_json\n\n request.body= generated_json\n\n http = Net::HTTP.new(uri.host, uri.port)\n http.open_timeout = HTTP_OPEN_TIMEOUT\n http.read_timeout = HTTP_READ_TIMEOUT\n \n # set enabled if you want to debug\n #http.set_debug_output $stdout\n\n if(uri.scheme == \"https\")\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n http.use_ssl= true\n end\n\n\n http.start do |http|\n response = http.request(request)\n\n #puts \"======== response ===========\"\n #puts response\n\n case response\n when Net::HTTPSuccess\n response_handler.process(response)\n when Net::HTTPBadGateway\n raise HttpConnectionException.new(\"Bad gateway\")\n when Net::HTTPUnauthorized\n raise AuthorizationFailedException.new(\"Wrong username or password.\")\n else\n raise HttpConnectionException.new(response.body)\n \n end\n\n end\n\n end",
"def process_http_request\n # the http request details are available via the following instance variables:\n # @http_protocol\n # @http_request_method\n # @http_cookie\n # @http_if_none_match\n # @http_content_type\n # @http_path_info\n # @http_request_uri\n # @http_query_string\n # @http_post_content\n # @http_headers\n handle(@http_request_method, @http_post_content)\n\n send_ok()\n end",
"def generate_post_request(ticket, forbid_connection_reuse)\r\n request = generate_ticket_request(ticket, forbid_connection_reuse)\r\n request.on_complete do |response|\r\n unless response.success?\r\n msg = if response.timed_out?\r\n 'Time out has occurred.'\r\n elsif response.code == 0\r\n response.return_message\r\n else\r\n \"HTTP request failed: #{response.code}\"\r\n end\r\n\r\n @log.log_error_message msg\r\n raise msg\r\n end\r\n end\r\n request\r\n end",
"def build_request\n uri = @config[:endpoint]\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n http.start\n request = build_request_stream(uri)\n return http, request\n end",
"def set_options(options={})\n @url = options[:url].dup if options.has_key?(:url) # Make sure @url is set, if not\n @method = options[:method] if options.has_key?(:method) # Make sure @method is set, if not\n @payload = options[:payload].dup if options.has_key?(:payload)\n\n @response_body = nil\n @response_header = nil\n @custom_header_handler = nil\n @custom_write_handler = nil\n\n # url should be a string that doesn't suck\n # method should be :post, :get, :put, :delete, :head\n # options should contain any of the following keys:\n # :headers, :response_header_handler, :response_body_handler, :payload (required if method = :post / :put)\n\n case @method\n when :get then connection.setopt :HTTPGET, 1\n when :head then connection.setopt :NOBODY, 1\n when :post then connection.setopt :POST, 1\n connection.setopt :POSTFIELDS, @payload\n connection.setopt :POSTFIELDSIZE, @payload.size\n when :put then connection.setopt :CUSTOMREQUEST, \"PUT\"\n connection.setopt :POSTFIELDS, @payload\n connection.setopt :POSTFIELDSIZE, @payload.size\n when :delete then connection.setopt :CUSTOMREQUEST, \"DELETE\"\n # else I WILL CUT YOU\n end\n\n if options.has_key?(:headers)\n set_headers(options[:headers]) unless options[:headers].nil?\n end\n\n if options.has_key?(:response_header_handler)\n @custom_header_handler = options[:response_header_handler]\n set_header_handler(:custom_header_callback)\n else\n @response_header = \"\"\n set_header_handler\n end\n\n if options.has_key?(:response_body_handler)\n @custom_write_handler = options[:response_body_handler]\n set_write_handler(:custom_write_callback)\n else\n @response_body = \"\"\n set_write_handler\n end\n\n connection.setopt :ENCODING, DEFAULT_CURL_ENCODING unless @method == :head\n connection.setopt :URL, @url\n\n # Other common options (blame streamly guy)\n connection.setopt :FOLLOWLOCATION, 1\n connection.setopt :MAXREDIRS, 3\n # @TODO: This should be an option\n connection.setopt :SSL_VERIFYPEER, 0\n connection.setopt :SSL_VERIFYHOST, 0\n\n connection.setopt :ERRORBUFFER, self.error_buffer\n\n return self\n end",
"def handle( request ) # note: all 'handle's return 'mlResponse' in a chain\n\n request.record_arrival_time\n mlResponse =\n case\n when request.get? then handle_get_muffin(request)\n when request.post? then handle_post(request)\n end\n request.record_completion_time\n mlResponse\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Sends a synchronous DELETE request. On success, yields any returned data; on error, yields any provided default data or +nil+. Recognizes the following options: +headers+ a hash to add or update the request headers +timeout+ the timeout for the request (defaults to +Ladon.default_request_timeout+) +default_data+ passes this on to +handle_response+
|
def fire_delete(url_or_path, options = {}, &block)
params = options.fetch(:params, {})
params.merge!(mapped_params(options))
url = absolute_url(url_or_path, params: params)
headers = {:Accept => MEDIA_TYPE_JSON}.merge(options.fetch(:headers, {}))
headers = merge_log_weasel_header(headers)
timeout = options.fetch(:timeout, Ladon.default_request_timeout)
response = Typhoeus::Request.delete(url, headers: headers, timeout: timeout)
handle_response(response, method: :delete, default_data: options[:default_data], url: url,
raise_on_error: options[:raise_on_error], &block)
end
|
[
"def delete(path, params={}); make_request(:delete, host, port, path, params); end",
"def http_delete(path, data = nil, content_type = 'application/json')\n http_methods(path, :delete, data, content_type)\n end",
"def request_delete(path, headers = {})\n http = Net::HTTP.new(REST_ENDPOINT, @options[:ssl] ? 443 : 80)\n\n http.use_ssl = @options[:ssl]\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n \n http.start do |http|\n req = sign_request(Net::HTTP::Delete.new(path), nil, headers)\n return http.request(req)\n end\n end",
"def delete_request\n client.create_request('DELETE', url_path)\n end",
"def delete(path, &block)\n request = Net::HTTP::Delete.new(path)\n\n send_request(request, nil, &block)\n end",
"def delete_async(uri, *args)\n request_async2(:delete, uri, argument_to_hash(args, :body, :header, :query))\n end",
"def http_delete(opts={})\n ret=http_delete_low(opts)\n if ret.is_a?(Hash) and ret.has_key?('error') and ret['error']=='Invalid Credentials' then\n\tauthdefault\n\tret=http_delete_low(opts)\n\treturn ret\n else\n\treturn ret\n end\n end",
"def make_delete_request\n\t\treturn Net::HTTP::Head.new( self.path, self.headers )\n\tend",
"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 send_delete(url,input_body,headers,http=nil)\n\n request = Net::HTTP::Delete.new( url )\n http = connect(@cfg['test_host'], @cfg['port']) if http==nil\n\n #Headers handling\n if headers != nil\n headers.each do |h|\n request.add_field h[0], h[1]\n end\n end\n\n #Body and response\n request.body = input_body\n request, response = send_request(http,request)\n return request, response\n\n end",
"def delete_data_stream 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_data_stream_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::Protobuf::Empty.decode_json response.body, ignore_unknown_fields: true\n\n yield result, operation if block_given?\n result\n end",
"def delete(path, params = {}, env = {}, &block)\n env[:request_method] = \"DELETE\"\n mock_request(path, params, env, &block)\n end",
"def delete\n if body.empty? && params[:id]\n client.delete(params)\n elsif body.empty?\n client.delete_by_query(params.merge(body: body.merge(ALL)))\n else\n client.delete_by_query(params.merge(body: body))\n end\n end",
"def DELETE(path, parameters=nil, headers=nil, ignore_throttle=false)\n url = path\n if parameters\n # URI escape each key and value, join them with '=', and join those pairs with '&'. Add\n # that to the URL with an prepended '?'.\n url += '?' + parameters.map {\n |k, v|\n [k, v].map {\n |x|\n CGI.escape(x.to_s)\n }.join('=')\n }.join('&')\n end\n\n headers ||= {}\n request = Net::HTTP::Delete.new(path_join(@version, @practiceid, url))\n call(request, {}, headers, false, ignore_throttle)\n end",
"def delete(z_api_args)\n # validate the resource URL\n error_msg = bad_uri?(z_api_args.uri)\n raise ArgumentError, error_msg if error_msg\n\n # For DELETE, reject if request_body is present\n request_body = z_api_args.req_body\n if request_body\n error_msg = \"Extraneous request body argument #{request_body.pretty_inspect.chomp} found.\"\n Z_Logger.instance.log(error_msg)\n raise ArgumentError, error_msg\n end\n\n # verify tenant's credential existence\n error_msg = credentials_exist?\n raise ArgumentError, error_msg if error_msg\n\n # may or may not have query string\n query_string = z_api_args.query_string ? z_api_args.query_string.to_hash : {}\n\n begin\n # if the caller has a block, yield with response after invocation\n if block_given?\n yield @z_api.exec_delete_api(z_api_args.uri, query_string)\n else\n @z_api.exec_delete_api(z_api_args.uri, query_string)\n end\n rescue Exception => e\n Z_Logger.instance(e.message)\n Z_Logger.instance.log(e.backtrace.join(\"\\n\"))\n raise RuntimeError, \"HTTP DELETE Exception. Please see logs for details.\"\n end\n end",
"def send_delete_request(endpoint, request_params)\n perform_and_handle_exceptions('u_hh_3', 'DELETE request Failed') do\n escaped_query_string = get_query_string(endpoint, request_params)\n raw_url = get_api_url(endpoint) + \"?#{escaped_query_string}\"\n uri = URI(raw_url)\n http = setup_request(uri)\n if @api_spec\n return {request_uri: uri.to_s.split(\"?\")[0], request_type: 'DELETE', request_params: escaped_query_string}\n else\n result = {}\n Timeout.timeout(@timeout) do\n result = http.delete(uri)\n end\n return format_response(result)\n end\n end\n end",
"def parallel_delete(requests, options = {})\n base_parallel_call(:delete, requests, options)\n end",
"def delete endpoint\n do_request :delete, endpoint\n end",
"def delete(query_url,\r\n headers: {},\r\n parameters: {})\r\n HttpRequest.new(HttpMethodEnum::DELETE,\r\n query_url,\r\n headers: headers,\r\n parameters: parameters)\r\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Returns a copy of +headers+ that includes a LogWeasel header if a LogWeasel transaction is in progress.
|
def merge_log_weasel_header(headers)
if LogWeasel::Transaction.id
headers.merge(LogWeasel::Middleware::KEY_HEADER => LogWeasel::Transaction.id)
else
headers
end
end
|
[
"def headers\n @headers ||= message.header_fields\n end",
"def headers(hash=nil)\n @headers = hash unless hash.nil?\n @headers ||= {}\n end",
"def headers(hash = nil || (return @headers))\n @headers.merge!(hash)\n end",
"def headers\n # units and source have to go last, so if we push in a new header, these go\n # at end\n @headers+['units','source']\n end",
"def headers\n @headers ||= HeaderHash.new(@http_response.to_hash)\n end",
"def headers\n @headers.to_a\n end",
"def lightstep_filtered_headers\n filtered_ot_headers = {}\n headers = request.headers.to_h\n headers.each do |k, v|\n fk = k.to_s.downcase.gsub('http_', '').tr('_', '-')\n next unless OPEN_TRACING_HEADER_KEYS.include?(fk)\n\n filtered_ot_headers[fk] = v\n end\n filtered_ot_headers\n end",
"def all_headers current_class = nil\n current_class ||= self\n return {} if current_class == Object\n current_header = current_class.headers || {}\n return current_header.merge all_headers(current_class.superclass)\n end",
"def entity_headers\n return headers_subset(ENTITY_HEADERS)\n end",
"def to_hash\n @headers.dup\n end",
"def with_headers(tmp_headers)\n current_headers = @headers\n set_headers(tmp_headers)\n yield\n ensure\n set_headers(current_headers)\n end",
"def headers hash=nil\n @response.headers.merge! hash if hash\n @response.headers\n end",
"def log_headers(headers)\n @api.logger.debug(headers.map {|k, v| [k, v].join(': ')}.join(', '))\n end",
"def allHeaders\n mailHeader = \"\"\n # --add CC\n mailHeader += \"CC: \" + @cc + \"\\n\" if (@cc != \"\")\n # --add BCC\n mailHeader += \"BCC: \" + @bcc + \"\\n\" if (@bcc != \"\")\n # --add From\n mailHeader += \"From: \" + @from + \"\\n\" if (@from != \"\")\n # --add extras\n @headers.each { |key, val|\n mailHeader += key + \": \" + val + \"\\n\"\n }\n mailHeader\n end",
"def header\n offset = LOG_HEADER_BLOCK_MAP[:LOG_FILE_HEADER] * Innodb::LogBlock::BLOCK_SIZE\n @header ||= block_cursor(offset).name(\"header\") do |c|\n Header.new(\n group_id: c.name(\"group_id\") { c.read_uint32 },\n start_lsn: c.name(\"start_lsn\") { c.read_uint64 },\n file_no: c.name(\"file_no\") { c.read_uint32 },\n created_by: c.name(\"created_by\") { c.read_string(32) }\n )\n end\n end",
"def header\n offset = LOG_HEADER_BLOCK_MAP[:LOG_FILE_HEADER] * Innodb::LogBlock::BLOCK_SIZE\n @header ||= block_cursor(offset).name(\"header\") do |c|\n {\n :group_id => c.name(\"group_id\") { c.get_uint32 },\n :start_lsn => c.name(\"start_lsn\") { c.get_uint64 },\n :file_no => c.name(\"file_no\") { c.get_uint32 },\n :created_by => c.name(\"created_by\") { c.get_string(32) }\n }\n end\n end",
"def index\n @transaction_headers = TransactionHeader.all\n end",
"def headers(*headers)\n raise ArgumentError, \"wrong number of arguments (0 for 1 or more)\" if headers.empty?\n @data[:headers] ||= {}\n\n unknown_headers = headers.to_set - @data[:headers].keys.to_set\n headers!(*unknown_headers) unless unknown_headers.empty?\n\n return @data[:headers][headers.first] if headers.length == 1\n @data[:headers].select { |k,v| headers.include? k }\n end",
"def add_headers hash\n Processor.new do |exchange|\n logging {\n out_channel = exchange.out\n hash.each { |k, v| out_channel.set_header k, v }\n }\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Returns the URL created by appending +url_or_path+ to the server's base URL, unless +url_or_path+ is alrady absolute.
|
def absolute_url(url_or_path, options= {})
url = url_or_path =~ /^#{base_url}/ ? url_or_path : "#{base_url}#{url_or_path}"
params = options.fetch(:params, {})
query = params.inject([]) do |rv, param|
rv.concat((param[1].is_a?(Array) ? param[1] : [param[1]]).map {|v| "#{uri_escape(param[0])}=#{uri_escape(v)}"})
rv
end
url += "?#{query.join('&')}" if query.any?
url
end
|
[
"def base_url(operation = nil)\n index = server_operation_index.fetch(operation, server_index)\n return \"#{scheme}://#{[host, base_path].join('/').gsub(/\\/+/, '/')}\".sub(/\\/+\\z/, '') if index == nil\n\n server_url(index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])\n end",
"def base_url(operation = nil)\n index = server_operation_index.fetch(operation.to_sym, server_index)\n return \"#{scheme}://#{[host, base_path].join('/').gsub(/\\/+/, '/')}\".sub(/\\/+\\z/, '') if index == nil\n\n server_url(index, server_operation_variables.fetch(operation.to_sym, server_variables), operation_server_settings[operation.to_sym])\n end",
"def base_url(operation = nil)\n if operation_server_settings.key?(operation) then\n index = server_operation_index.fetch(operation, server_index)\n server_url(index.nil? ? 0 : index, server_operation_variables.fetch(operation, server_variables), operation_server_settings[operation])\n else\n server_index.nil? ? \"#{scheme}://#{[host, base_path].join('/').gsub(/\\/+/, '/')}\".sub(/\\/+\\z/, '') : server_url(server_index, server_variables, nil)\n end\n end",
"def full_url_for(path)\n path = full_path_for(path)\n uri = request.request_uri\n host = uri.scheme + \"://\" + uri.host\n port = uri.port\n host << \":#{port}\" unless port == 80\n \"#{host}#{path}\"\n end",
"def base_url\n current_base_href = base_href.to_s.strip.empty? ? nil : URL.absolutify(base_href, URL.new(url).root_url)\n current_base_href || url\n end",
"def uri(addr = nil, absolute = true, add_script_name = true)\n addr = addr.to_s if addr\n return addr if addr =~ /\\A[A-z][A-z0-9\\+\\.\\-]*:/\n uri = if absolute\n h = if @env.has_key?(\"HTTP_X_FORWARDED_HOST\") || port != (ssl? ? 443 : 80)\n host_with_port\n else\n host\n end\n [\"http#{'s' if ssl?}://#{h}\"]\n else\n ['']\n end\n uri << script_name.to_s if add_script_name\n uri << (addr || path_info)\n File.join(uri)\n end",
"def full_url(path)\n \"#{base_url}#{path}\"\n end",
"def absolute_url(relative)\n \"#{server_url}#{relative}\"\n end",
"def join_url(base_url, path)\n return path if(path.include?(':')) # Absolute URL contains ':'\n if(path[0..0] == '/')\n new_url = base_url.clone\n new_url.path = path\n new_url.to_s\n else\n (base_file_url + path).to_s\n end\n end",
"def build_url(host)\n host.protocol + host.url\n end",
"def generate_url(path)\n if path =~ /^\\//\n path.sub!('/', '')\n end\n path = \"#{@base_url}/#{path}\"\n end",
"def url(relative_path = nil)\n self.server.url(path(relative_path))\n end",
"def build_url(host)\n host.protocol + host.url\n end",
"def make_url\n made_url = nil\n if has_url_dynvar?\n made_url = @url\n else\n protocol, resource = @config.base_url_and_port.split('://')\n resource = resource + '/' + @url unless @url.blank?\n if is_get? && has_params?\n params = self.content_string.to_s.gsub('%2B', '+')\n resource = resource + '?' + params\n end\n made_url = protocol + '://' + resource.gsub(/\\/+/, '/')\n end\n made_url\n end",
"def initial_url\n if URI.parse(@url).path == ''\n \"#{@url}/\"\n else\n @url\n end\n end",
"def url\n ::File.join \"/\", path.to_s\n end",
"def absolute_url(*args)\n # FIXME: arrgh, why request.protocol returns http://?\n # :// is not part of protocol name\n options = extract_options_from_args!(args) || {}\n protocol = options.delete(:protocol)\n host = options.delete(:host)\n \n raise ArgumentError, \"The :protocol option must be specified\" unless protocol\n raise ArgumentError, \"The :host option must be specified\" unless host\n \n args << options\n \n protocol + \"://\" + host + url(*args)\n end",
"def file_url(path)\n return nil if base_dir.nil?\n File.join(base_url, path)\n end",
"def abs_url url, host\n uri = url\n if uri && uri !~ /^http/\n uri = \"//#{host}#{uri}\"\n end\n uri\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Encodes +entity_ as a JSON string.
|
def encode_entity(entity)
Yajl::Encoder.encode(entity)
end
|
[
"def serialize(entity)\n @coercer.to_record(entity)\n end",
"def _serialize(entity)\n @collection.serialize(entity)\n end",
"def serialize_item(entity)\n Hash[entity.map { |k, v| [k.to_s, format_attribute_value(v)] }]\n end",
"def json_encoder; end",
"def encode\n Base64.encode64(to_json)\n end",
"def escape_html_entities_in_json=(_arg0); end",
"def returnEntity()\n result = \"<Entity Type=\\\"#{@entityType}\\\">\\n\"\n result.concat(\"<Value>#{@value}</Value>\\n\")\n result.concat(\"<Weight>#{@weight}</Weight>\\n\")\n #Add Display Info if present\n if @displayInformation.length > 0\n result.concat(\"<DisplayInformation><Label Name=\\\"\\\" Type=\\\"text/html\\\"><![CDATA[#{@displayInformation}]]></Label></DisplayInformation>\\n\")\n end\n #Add Additional Field if present\n if @additionalFields.length > 0\n result.concat(\"<AdditionalFields>\\n\")\n @additionalFields.each do |additionalField|\n if additionalField['MatchingRule'] == nil\n result.concat(\"<Field Name=\\\"#{additionalField['FieldName']}\\\" DisplayName=\\\"#{additionalField['DisplayName']}\\\">#{additionalField['Value']}</Field>\\n\")\n else\n result.concat(\"<Field MatchingRule=\\\"#{additionalField['MatchingRule']}\\\" Name=\\\"#{additionalField['FieldName']}\\\" DisplayName=\\\"#{additionalField['DisplayName']}\\\">#{additionalField['Value']}</Field>\\n\")\n end\n end\n result.concat(\"</AdditionalFields>\\n\")\n end\n if @iconURL.length > 0\n result.concat(\"<IconURL>#{@iconURL}</IconURL>\\n\")\n end\n result.concat(\"</Entity>\\n\")\n return result\n end",
"def jsonify thing\n Yajl::Encoder.encode thing\n end",
"def create(entity)\n post(resource_path_for_entity(entity), entity.to_json)\n end",
"def serialize(thing)\n Serializer::serialize(thing).to_json\n end",
"def json_encode(string)\n string.to_json\n end",
"def standard_encode\n encode_entities(:basic).gsub(/'/, ''')\n end",
"def add_entity\n res = {\n :success => false,\n :msg => '',\n :data => {}\n }\n if (params[:id].nil?)\n res[:msg] = 'order/update_entity was called without an :id'\n return render(:json => res.to_json, :layout => false)\n end\n \n order = Order.find_by_id(params[:id])\n entities = order.type.entities\n entities.each do |e|\n if (e.name == params[\"entity\"])\n data = params[e.name]\n data[:order_id] = params[:id]\n data[:order_type_entity_id] = e.id\n oe = OrderEntity.create(data)\n \n res[:success] = true\n res[:data][:entity] = oe.to_h\n res[:msg] = \"Added #{oe.type.name.capitalize}\" \n end\n end \n render :json => res.to_json, :layout => false \n end",
"def create\n @entity = Entity.new(entity_params[:entity])\n \n if @entity.save\n render json: @entity\n else\n render json: @entity.errors\n end\n end",
"def serialize_key(entity)\n Hash[key_schema.keys.each_with_index.map do |k, idx|\n v = entity.is_a?(Hash) ? entity[k] : entity[idx]\n [k.to_s, format_attribute_value(v)]\n end]\n end",
"def encode\n @content.serialize_to_string\n end",
"def encode_entities(*instructions)\n str = nil\n if (instructions.empty?)\n instructions = [:basic] \n else\n instructions.each do |instr|\n unless ENCODE_ENTITIES_COMMAND_ORDER[instr]\n raise RuntimeError, \"unknown encode_entities command `#{instr.inspect}'\"\n end\n end\n instructions.sort! { |a,b|\n ENCODE_ENTITIES_COMMAND_ORDER[a] <=>\n ENCODE_ENTITIES_COMMAND_ORDER[b]\n }\n end\n instructions.each do |instruction|\n case instruction\n when :basic\n # Handled as basic ASCII\n str = (str || self).gsub(HTMLEntities::BASIC_ENTITY_REGEXP) {\n # It's safe to use the simpler [0] here because we know\n # that the basic entities are ASCII.\n '&' << HTMLEntities::REVERSE_MAP[$&[0]] << ';'\n }\n when :named\n # Test everything except printable ASCII \n str = (str || self).gsub(HTMLEntities::UTF8_NON_ASCII_REGEXP) {\n cp = $&.unpack('U')[0]\n (e = HTMLEntities::REVERSE_MAP[cp]) ? \"&#{e};\" : $&\n }\n when :decimal\n str = (str || self).gsub(HTMLEntities::UTF8_NON_ASCII_REGEXP) {\n \"&##{$&.unpack('U')[0]};\"\n }\n when :hexadecimal\n str = (str || self).gsub(HTMLEntities::UTF8_NON_ASCII_REGEXP) {\n \"&#x#{$&.unpack('U')[0].to_s(16)};\"\n }\n end \n end\n return str\n end",
"def define_entity\n send_json_error(['entity model is not defined'], :internal_server_error)\n end",
"def encode(options = {})\n if defined?(ActiveResource::VERSION) && ActiveResource::VERSION::MAJOR == 3\n if respond_to?(\"to_#{self.class.format.extension}\")\n super(options)\n else\n self.class.format.encode(attributes, options)\n end\n else\n super(options)\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Converts +entity+ from a JSON string to an object.
|
def parse_entity(entity)
entity = Yajl::Parser.parse(entity)
entity.is_a?(Hash) ? HashWithIndifferentAccess.new(entity) : entity
end
|
[
"def jsonapi_to_entity(response, data)\n return data unless data['type']\n\n data['type'].classify.constantize.make(self, data, response: response)\n rescue => error\n raise Oops(\n error: 'Cannot construct Entity from data',\n data: data,\n wrapped: error,\n )\n end",
"def from_json string\n _assign_attributes JSON.parse(string)\n end",
"def from_json(json:, klass:)\n hash = JSON.load(json)\n from_hash(hash: hash, klass: klass)\n end",
"def _deserialize(entity)\n deserialize([entity])\n end",
"def from_json(json)\n deserialize JSON.parse(json)\n end",
"def from_json!(string)\n JSON.parse(string).each do |var, val|\n self.instance_variable_set var, val\n end\n end",
"def from_json(value, record)\n value\n end",
"def from_str(str)\n doc = JSON.parse(str)\n if doc.class != Array\n raise JsonReaderError, \"Parsed JSON document is not a JSON object, nor a JSON array\"\n end\n\n JsonReader.new(doc)\n end",
"def reparsed_from_json\n self.is_a?(String) ? JSON.parse(self) : JSON.parse(self.to_json)\n end",
"def deserialize(json_string)\n return JSON.parse(json_string)\nend",
"def test_parse_object_from_json\n object_json = '{\"submitter\":\"Andy Olsen\",\"period\":\"01 Jan 2016 00:00:00 UST/1\",\"random\":\"Now is the time for all great men...\",\"hash\":\"433952842a6d452b69134238c5a40dc87ece8c3cbb6c3ec2bfc2048a34aff583\"}'\n dish = GTS::Dish.new\n dish.parse(object_json)\n assert_equal(dish.submitter, 'Andy Olsen')\n assert_equal(dish.period, '01 Jan 2016 00:00:00 UST/1')\n assert_equal(dish.random, 'Now is the time for all great men...')\n end",
"def from_json(json, opts=OPTS)\n v = Sequel.parse_json(json)\n case v\n when self\n v\n when Hash\n new.from_json_node(v, opts)\n else\n raise Error, \"parsed json doesn't return a hash or instance of #{self}\"\n end\n end",
"def load(json)\n require 'json'\n from_json(JSON.parse(json))\n end",
"def parse_json(string)\n JSON.parse string\n end",
"def define_models_from_json_string(string)\n define_models(JSON.parse(string)) if string\n end",
"def parse_json_object(input)\n if defined? JSON\n JSON.parse(input)\n else\n json_objparse(input)\n end\nend",
"def from_json(json_text)\n # raise json_text.inspect\n set_config(JSON.parse(json_text.gsub(\"\\r\\n\", '')))\n self\n end",
"def convert_json_trace_to_object(trace)\n JSON.parse(trace[1...-1].insert(0, '{'), object_class: OpenStruct)\n end",
"def obj(arg)\n str = ent(arg)\n flatparse(str)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
Converts options to a pager. If none of the below described options is provided, returns +nil+.
|
def pager(options)
pager = if options.include?(:pager)
options[:pager]
elsif options[:paged] || options[:pre_paged] || options[:page].present? || options[:per].present?
Ladon::Pager.new(options)
end
end
|
[
"def best_available\n if !_pry_.config.pager\n NullPager.new(_pry_.output)\n elsif !SystemPager.available? || Helpers::Platform.jruby?\n SimplePager.new(_pry_.output)\n else\n SystemPager.new(_pry_.output)\n end\n end",
"def best_available\n if !_pry_.config.pager\n NullPager.new(_pry_.output)\n elsif !SystemPager.available? || Pry::Helpers::BaseHelpers.jruby?\n SimplePager.new(_pry_.output)\n else\n SystemPager.new(_pry_.output)\n end\n end",
"def setup_pager\n unless @use_stdout then\n for pager in [ ENV['PAGER'], \"less\", \"more\", 'pager' ].compact.uniq\n return IO.popen(pager, \"w\") rescue nil\n end\n @use_stdout = true\n nil\n end\n end",
"def pager\n CmdConsole::Pager.new(self)\n end",
"def pager\n Pry::Pager.new(self)\n end",
"def select_pager(enabled: true, command: nil)\n commands = Array(command)\n\n if !enabled\n NullPager\n elsif SystemPager.exec_available?(*commands)\n SystemPager\n else\n BasicPager\n end\n end",
"def populate_pagination_attributes_from_options(options={})\n self.page = options[:page] || page || 1\n self.per_page = options[:per_page] || per_page || 50\n end",
"def extract_pagination(options)\n if (value = options.delete(AUTO_PAGINATION))\n api.auto_pagination = value\n end\n end",
"def setup_pager\n return if @use_stdout\n\n jruby = RUBY_ENGINE == 'jruby'\n\n pagers = [ENV['RI_PAGER'], ENV['PAGER'], 'pager', 'less', 'more']\n\n pagers.compact.uniq.each do |pager|\n next unless pager\n\n pager_cmd = pager.split(' ').first\n\n next unless in_path? pager_cmd\n\n if jruby then\n case io = find_pager_jruby(pager)\n when nil then break\n when false then next\n else io\n end\n else\n io = IO.popen(pager, 'w') rescue next\n end\n\n next if $? and $?.pid == io.pid and $?.exited? # pager didn't work\n\n @paging = true\n\n return io\n end\n\n @use_stdout = true\n\n nil\n end",
"def spawn_pager\n # In case there's a previous pager running:\n close\n\n command = pager_command\n status = self.class.run_command(command)\n # Issue running command, e.g. unsupported flag, fallback to just command\n unless status\n command = pager_command.split.first\n end\n\n PagerIO.new(command)\n end",
"def extract_page(options)\n Api::Sanitize.page(options[:page])\n end",
"def paginate(options = {})\n super(prepare_options(options))\n end",
"def extract_per_page(options)\n Api::Sanitize.per_page_hash(options)\n end",
"def will_paginate(collection_or_options = nil, options = {})\n if collection_or_options.is_a? Hash\n options, collection_or_options = collection_or_options, nil\n end\n unless options[:renderer]\n options = options.merge :renderer => BootstrapPagination::Rails\n end\n super *[collection_or_options, options].compact\n end",
"def paginate(options = {})\n page = options.delete(:page) || raise(ArgumentError, \"paginate requires a :page argument\")\n per_page = options.delete(:per_page)\n raise ArgumentError, \"unknown argument #{options.keys.first.inspect} passed to paginate\" unless options.empty?\n @query.paginate(page, per_page)\n end",
"def no_pager pry=(defined?(_pry_) && _pry_) || Pry, &block\n boolean = pry.config.pager\n pry.config.pager = false\n yield\n ensure\n pry.config.pager = boolean\n end",
"def pages(repo, options = T.unsafe(nil)); end",
"def find_or_create_view options\n if options.is_a? Hash\n View.find_or_create_page(:user => self, :page => options[:page]) if options[:page]\n end\n end",
"def pages( options = {} )\n options = {:kind => nil, :pages => @pages, :params => {}}.merge(options)\n if options[:pages] and options[:pages].page_count > 1\n html = <<-END\n <div class=\"pages\">\n Page: #{pagination_links(options[:pages], {:window_size => 6, :params => params.merge(options[:params]).reject { |key,value| key == 'controller' }}).sub(/\\d+(?=\\s|$)/, '<span class=\"this_page\">\\&</span>').sub(\"...\", '<span class=\"break\">...</span>')}\n #{options[:kind].nil? ? \"\" : \"(#{options[:pages].last_page.last_item} #{options[:kind]})\"}\n </div>\n END\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns lowest sum of the winning and losing teams' scores
|
def lowest_total_score
total_game_scores = games.map { |game| game.home_goals + game.away_goals}
total_game_scores.min
end
|
[
"def winning_team\n brooklyn_players = team_player_info(\"Brooklyn Nets\")\n charlotte_players = team_player_info(\"Charlotte Hornets\")\n\n brooklyn_scores = brooklyn_players.map {|stats|\n stats[:points]}\n\n charlotte_scores = charlotte_players.map {|stats|\n stats[:points]}\n \n brooklyn_total = brooklyn_scores.sum\n charlotte_total = charlotte_scores.sum\n\n charlotte_total > brooklyn_total ? (return charlotte_total) : (return brooklyn_total)\nend",
"def winning_score\n return 0 unless winning_team_game\n winning_team_game.total_score\n end",
"def total_score(team)\n points = {name: team, total_scored: 0 , total_suffered: 0, point_balance: 0, wins: 0, losses: 0, victory_balance: 0}\n $teams.each do |game|\n if points[:name] == game[:home_team]\n points[:total_scored] += game[:home_score]\n points[:total_suffered] += game[:away_score]\n points[:wins] += 1 if game[:home_score] > game[:away_score]\n points[:losses] += 1 if game[:home_score] < game[:away_score]\n elsif points[:name] == game[:away_team]\n points[:total_scored] += game[:away_score]\n points[:total_suffered] += game[:home_score]\n points[:wins] += 1 if game[:home_score] < game[:away_score]\n points[:losses] += 1 if game[:home_score] > game[:away_score]\n end\n end\n points[:victory_balance] = points[:wins] - points[:losses]\n points[:point_balance] = points[:total_scored] - points[:total_suffered]\n\n return points\nend",
"def fewest_goals_scored(team_id)\n (away_goals_scored(team_id) + home_goals_scored(team_id)).min\n end",
"def winning_team_game\n self.team_games.sort_by { |team_game| team_game.total_score }.last\n end",
"def lowest_scoring_home_team\n foo = {}\n\n teams.each do |team|\n team_id = team['team_id']\n team_name = team['teamName']\n\n foo[team_name] = average_goals_home(team_id)\n end\n\n foo.max_by { |_k, v| -v }[0]\n end",
"def winning_team\n if homeTeamPoints.sum > awayTeamPoints.sum\n \"Brooklyn Nets\"\n else\n \"Charlotte Hornets\"\n end\nend",
"def calculate_winner_scores\n winner_team_id = get_winner\n \n winner_scores = Array.new\n for game in games\n scores = GameScore.get_scores_with_id(game.id)\n for score in scores\n if score.team_id.to_s == winner_team_id\n winner_scores.insert(-1, score)\n end\n end\n end \n \n return winner_scores\n end",
"def find_best_score(total_per_player)\n best_score = 0\n winner = ''\n total_per_player.each do |player_name,total|\n\n if total > best_score\n best_score = total\n winner = player_name\n end\n end\n return winner\n end",
"def winning_team\r\n total_points = 0\r\n win_team = ''\r\n game_hash.each do |home_away, keys|\r\n team_points = 0\r\n team_name = game_hash[home_away][:team_name]\r\n keys[:players].each do |player|\r\n points = player[:points]\r\n team_points += points\r\n end\r\n win_team, total_points = team_name, team_points if team_points > total_points\r\n end\r\n return win_team\r\nend",
"def total_team_score(teams_id)\n total_score = 0\n @league_data.each do\n |team| \n # binding.pry\n if team.home_team_id == teams_id\n total_score += team.home_team_score\n elsif team.away_team_id == teams_id\n total_score += team.away_team_score\n end\n end\n return total_score\n end",
"def score_per_winner\n number_of_winners = @players.select { |p| p.points == minimum_points }.count\n (total_score / number_of_winners.to_i)\n end",
"def lowest_scoring_home_team\n @teams.min_by { |team| team.average_home_goals }.team_name\n end",
"def fewest_goals_scored(team_id)\n team_id = team_id.to_i\n goals_per_game = @game_teams.map do |game|\n if game.team_id == team_id\n game.goals\n end\n end\n goals_per_game.compact.min\n end",
"def doubles_wins\n total_wins = 0\n get_teams.each{ |team| total_wins += team.doubles_results.sum(:win)}\n total_wins\n end",
"def rank\n x = self.how_many_wins.to_f\n y = self.how_many_wins.to_f + self.how_many_losses.to_f\n if y == 0\n y = 1\n end\n score = x / y\n return score\n end",
"def teams_left\n return 1 + @winners.inject(0) { |memo, arr| arr.inject(memo) {|memo2, team| memo2 += (team == UNKNOWN_TEAM ? 1 : 0)} }\n end",
"def compute_team_scores\n team_scores = []\n meeting_team_scores = []\n max_swimmers_count = 0\n max_relays_count = 0\n\n # Computes individuals and relays scores and swimmers and relays total per team\n @teams.each do |team|\n team_score = {}\n team_score[:team] = team\n team_score[:sum_individual_points] = compute_individual_points_for_team(team)\n team_score[:sum_relay_points] = compute_relay_points_for_team(team)\n team_score[:swimmers_count] = retrieve_max_ranked_swimmers_for_team(team)\n team_score[:relays_count] = retrieve_max_considered_relays_for_team(team)\n team_score[:swimmers_bonus] = 0\n team_score[:relays_bonus] = 0\n team_scores << team_score\n\n # Find out maximum swimmers and relays count\n max_swimmers_count = team_score[:swimmers_count] if team_score[:swimmers_count] > max_swimmers_count\n max_relays_count = team_score[:relays_count] if team_score[:relays_count] > max_relays_count\n end\n\n # Not necessary in rank not used\n # Computes bonuses\n # team_scores.each do |team_score|\n # team_score[:swimmers_bonus] = max_swimmers_count - team_score[:swimmers_count]\n # team_score[:relays_bonus] = max_relays_count - team_score[:relays_count]\n # end\n\n # Create meeting team score\n team_scores.each_with_index do |team_score, _index|\n # Verify if meeting team score already exixts\n meeting_team_score = @meeting.meeting_team_scores.where(['meeting_team_scores.team_id = ?', team_score[:team].id]).first\n unless meeting_team_score\n # Create a new tmeeting team score instance\n meeting_team_score = MeetingTeamScore.new\n meeting_team_score.meeting_id = @meeting.id\n meeting_team_score.season_id = @meeting.season_id\n meeting_team_score.team_id = team_score[:team].id\n meeting_team_score.team_affiliation_id = team_score[:team].team_affiliations.where(['team_affiliations.season_id = ?', @meeting.season_id]).first.id\n # TODO: use current user\n meeting_team_score.user_id = 2\n end\n\n # Not in use\n meeting_team_score.rank = 0\n\n # Assigns scores\n meeting_team_score.sum_individual_points = team_score[:sum_individual_points]\n meeting_team_score.sum_relay_points = team_score[:sum_relay_points]\n meeting_team_score.sum_team_points = max_swimmers_count - team_score[:swimmers_count] + max_relays_count - team_score[:relays_count]\n meeting_team_score.meeting_individual_points = meeting_team_score.sum_individual_points\n meeting_team_score.meeting_relay_points = meeting_team_score.sum_relay_points\n meeting_team_score.meeting_team_points = meeting_team_score.sum_team_points\n meeting_team_score.season_individual_points = meeting_team_score.sum_individual_points\n meeting_team_score.season_relay_points = meeting_team_score.sum_relay_points\n meeting_team_score.season_team_points = meeting_team_score.sum_team_points\n meeting_team_scores << meeting_team_score\n end\n\n meeting_team_scores\n end",
"def doubles_losses\n total_wins = 0\n get_teams.each {|team| total_wins += team.doubles_results.sum(:loss)}\n total_wins\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns venue with most games played
|
def most_popular_venue
venues = @games.group_by { |game| game.venue}
venues.max_by { |venue, games| games.count }.first
end
|
[
"def order_games_by_venue\n most_popular_venue = Hash.new(0)\n sort_games_by_venue.each do |venue|\n most_popular_venue[venue] += 1\n end\n most_popular_venue\n end",
"def least_popular_venue\n venues = @games.group_by { |game| game.venue}\n venues.min_by { |venue, games| games.count }.first\n end",
"def season_with_most_games\n seasons = @games.group_by { |game| game.season }\n seasons.max_by { |season, games| games.count }.first\n end",
"def popular_venue\n lis = self.listings.map {|l| l.venue_id}\n counts = Hash.new 0\n lis.each do |id|\n counts[id] += 1\n end\n popular = 0\n appearances = 0\n counts.each do |id, value|\n if value > appearances \n appearances = value\n popular = id\n end\n end\n Venue.find(popular)\n end",
"def winning_team_game\n self.team_games.sort_by { |team_game| team_game.total_score }.last\n end",
"def biggestShoes\n players.max_by do|name, stats|\n stats[:shoe]\n end\nend",
"def season_with_fewest_games\n seasons = @games.group_by { |game| game.season }\n seasons.min_by { |season, games| games.count }.first\n end",
"def top_teams\n plays = self.plays.where(:selection => [\"Favorite\", \"Underdog\"])\n counts = Hash.new(0)\n plays.each do |p|\n p.selection == \"Favorite\" ? \"#{team = p.game.favorite}\" : \"#{team = p.game.underdog}\"\n counts[team] +=1\n puts counts.inspect\n end\n end",
"def winningest_team\n @teams.max_by { |team| team.total_win_percentage }.team_name\n end",
"def top_games(limit=10)\n placeholder = SecureRandom.uuid.downcase.gsub('-', '')\n games = Event.connection.execute(\n <<-SQL\n select * from (\n select\n regexp_replace(initcap(regexp_replace(lower(t.title), '''', '#{placeholder}')), '#{placeholder}', '''', 'i' ) as title\n ,t.id as title_id\n ,count(distinct c.id) as checkouts\n from games g\n left join (select * from checkouts where event_id = #{self.id}) c on g.id = c.game_id\n inner join titles t on t.id = g.title_id\n where\n g.status = #{Game::STATUS[:active]}\n or (g.status = #{Game::STATUS[:culled]} and g.updated_at::date between '#{self.start_date}' and '#{self.end_date}')\n or (g.status = #{Game::STATUS[:stored]} and g.updated_at::date between '#{self.start_date}' and '#{self.end_date}')\n group by 2\n order by 3 desc,1\n ) c\n where checkouts > 0\n limit '#{Event.connection.quote(limit)}'\n SQL\n )\n games.map do |game|\n game[:available] = Game.copy_available(game[\"title_id\"])\n game\n end\n end",
"def highest_scoring_visitor\n @teams.max_by { |team| team.average_away_goals }.team_name\n end",
"def most_wins_per_game(game)\n user_hash = Hash.new\n user_hash[:wins] = 0\n\n User.all.each do |user|\n current_user_wins = 0\n\n user_matches = user.p1_matches.where(\"game_id = ?\", game.id) +\n user.p2_matches.where(\"game_id = ?\", game.id)\n \n user_matches.each do |match|\n if match.winner_id == user.id && match.finalized_date != nil\n current_user_wins += 1\n end\n end\n\n if current_user_wins > user_hash[:wins]\n user_hash[:user] = user\n user_hash[:wins] = current_user_wins\n end\n end\n\n user_hash\n end",
"def most_wins_all_games\n user_hash = Hash.new\n user_hash[:wins] = 0\n\n User.all.each do |user|\n current_user_wins = 0\n \n user.matches.each do |match|\n if match.winner_id == user.id && match.finalized_date != nil\n current_user_wins += 1\n end\n end\n\n if current_user_wins > user_hash[:wins]\n user_hash[:user] = user\n user_hash[:wins] = current_user_wins\n end\n end\n\n user_hash\n end",
"def most_popular_hobby\n arr = self.my_hobbies\n most_popular = arr.uniq.max_by {|i| arr.count(i)}\n end",
"def play_best_of_game_set\n while game.highest_player_score < best_of\n play_game\n end\n publish_winners(game.players_with_highest_score, \"game\")\n end",
"def big_shoe_rebounds \n \n biggest_shoes_rebound_count = 0\n player_with_the_biggest_shoes = who_has_biggest_shoes\n \n game_hash.each do |side, data|\n data[:players].each do |players, stats|\n if players == who_has_biggest_shoes\n \n stats.each do |specific_stat, specific_stat_value|\n if specific_stat == :rebounds\n biggest_shoes_rebound_count = specific_stat_value\n end #end if\n end #end stat_list each\n \n end #end if players has biggest shoes\n end #end data each\n end #end game hash\n biggest_shoes_rebound_count\nend",
"def highest_number_of_bets\n match_hash = Hash.new\n match_hash[:count] = 0\n\n Match.all.each do |match|\n current_bet_count = match.bets.count\n if current_bet_count > match_hash[:count]\n match_hash[:match] = match\n match_hash[:count] = current_bet_count\n end\n end\n\n match_hash\n end",
"def most_popular_time()\n films_array=Film.all()\n films_array.each {|film|\n tickets_array = Screening.tickets_all()\n most_popular = tickets_array.max()}\n return most_popular\n end",
"def player_with_most_steals\n most_steals = 0\n most_steals_player = 0\n game_hash.each do |location, attributes|\n attributes[:players].each do |category|\n if category[:steals] > most_steals\n most_steals = category[:steals]\n most_steals_player = category[:player_name]\n end\n end\n end\n most_steals_player\nend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns venue with least games played
|
def least_popular_venue
venues = @games.group_by { |game| game.venue}
venues.min_by { |venue, games| games.count }.first
end
|
[
"def season_with_fewest_games\n seasons = @games.group_by { |game| game.season }\n seasons.min_by { |season, games| games.count }.first\n end",
"def most_popular_venue\n venues = @games.group_by { |game| game.venue}\n venues.max_by { |venue, games| games.count }.first\n end",
"def lowest_total_score\n total_game_scores = games.map { |game| game.home_goals + game.away_goals}\n total_game_scores.min\n end",
"def order_games_by_venue\n most_popular_venue = Hash.new(0)\n sort_games_by_venue.each do |venue|\n most_popular_venue[venue] += 1\n end\n most_popular_venue\n end",
"def season_with_most_games\n seasons = @games.group_by { |game| game.season }\n seasons.max_by { |season, games| games.count }.first\n end",
"def play_best_of_game_set\n while game.highest_player_score < best_of\n play_game\n end\n publish_winners(game.players_with_highest_score, \"game\")\n end",
"def winning_team_game\n self.team_games.sort_by { |team_game| team_game.total_score }.last\n end",
"def minimum_match_count\n lowest = @set.length\n @possible_guesses.each do |possible|\n count = highest_match_count(possible)\n lowest = count if count < lowest\n end\n lowest\n end",
"def won_games\n Game.includes(:scores)\n .where(blue_team_id: self.id).or(Game.includes(:scores).where(white_team_id: self.id))\n .select do |game|\n (game.blue_team_id == self.id && game.blue_goals > game.white_goals) ||\n (game.white_team_id == self.id && game.white_goals > game.blue_goals)\n end\n end",
"def popular_venue\n lis = self.listings.map {|l| l.venue_id}\n counts = Hash.new 0\n lis.each do |id|\n counts[id] += 1\n end\n popular = 0\n appearances = 0\n counts.each do |id, value|\n if value > appearances \n appearances = value\n popular = id\n end\n end\n Venue.find(popular)\n end",
"def smallest_team\n self.teams.min{|t1,t2| t1.runners.size <=> t2.runners.size }\n end",
"def find_winners\n # debugger\n all_players = @empty_players + players\n sorted_players = all_players.sort_by { |player| player.matches }\n most_matches = sorted_players[-1].matches\n i = all_players.length-1\n while sorted_players[i].matches == most_matches do\n winners.push(sorted_players[i])\n i -= 1\n break if i < 0\n end\n @most_matches = most_matches\n end",
"def winningest_coach(season)\n coach_win_percentage_hash = coach_win_percentage_helper(season)\n best_win_percentage = 0.0\n best_coach = \"\"\n\n coach_win_percentage_hash.each do |coach, win_percentage|\n if win_percentage > best_win_percentage\n best_win_percentage = win_percentage\n best_coach = coach\n end\n end\n best_coach\n end",
"def player_with_most_steals\n most_steals = 0\n most_steals_player = 0\n game_hash.each do |location, attributes|\n attributes[:players].each do |category|\n if category[:steals] > most_steals\n most_steals = category[:steals]\n most_steals_player = category[:player_name]\n end\n end\n end\n most_steals_player\nend",
"def player_with_most_steal\n most_steals = nil\n most_steal_player = nil\n\n all_players(game_hash).each do |player|\n if most_steals == nil || player[:steals] > most_steals\n most_steals = player[:steals]\n most_steal_player = player[:player_name]\n end\n end\n\n most_steal_player\nend",
"def fewest_goals_scored(team_id)\n team_id = team_id.to_i\n goals_per_game = @game_teams.map do |game|\n if game.team_id == team_id\n game.goals\n end\n end\n goals_per_game.compact.min\n end",
"def lowest_scoring_home_team\n @teams.min_by { |team| team.average_home_goals }.team_name\n end",
"def lowest_scoring_home_team\n foo = {}\n\n teams.each do |team|\n team_id = team['team_id']\n team_name = team['teamName']\n\n foo[team_name] = average_goals_home(team_id)\n end\n\n foo.max_by { |_k, v| -v }[0]\n end",
"def lowest_score\n sort\n all.last.score\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns percentage of games a home team has won
|
def percentage_home_wins
home_wins = @teams.map { |team| team.home_wins }.sum
home_games = @teams.map { |team| team.home_games }.sum
(home_wins.to_f / home_games.to_f).round(2)
end
|
[
"def percentage_home_wins\n home_wins = 0\n self.games.each_value do |object|\n if object.home_goals > object.away_goals\n home_wins += 1\n end\n end\n\n (home_wins / (self.games.length).to_f).round(2)\n end",
"def games_win_percentage(team_id, games)\n total = games.count\n won = 0\n games.each do |game|\n if (team_id == game.away_team_id) && game.outcome.match?(/away win/)\n won += 1\n elsif (team_id == game.home_team_id) && game.outcome.match?(/home win/)\n won += 1\n else\n won += 0\n end\n end\n won.to_f / total\n end",
"def percentage_visitor_wins\n visitor_wins = @teams.map { |team| team.away_wins }.sum\n visitor_games = @teams.map { |team| team.away_games }.sum\n (visitor_wins.to_f / visitor_games.to_f).round(2)\n end",
"def calculate_winning_percentage\n games_played = self.won + self.lost\n if games_played == 0\n self.winning_percentage = 0.0\n else\n self.winning_percentage = (self.won*1.0)/games_played\n end\n end",
"def percent_wins(wins)\n ((wins.to_f / @num_games.to_f) * 100).round(4)\n end",
"def win_percent\n matchmade_games < 1 ? 0 : ((total_exp.to_f/matchmade_games.to_f) * 100).to_d\n end",
"def average_goals_per_game\n total_goals = @teams.map {|team| team.total_goals_scored}.sum\n total_games = @teams.map {|team| team.home_games}.sum\n (total_goals.to_f / total_games.to_f).round(2)\n end",
"def get_opponents_average_win_percentage\n opponents_win_percentages = 0.0\n opponent_ids = self.get_opponent_ids\n opponents_matchup_ids = self.get_opponents_matchup_ids\n opponent_ids.each do |i|\n opponents_win_count = Matchup.where({\"id\" => opponents_matchup_ids}, {\"winner_id\" => i}).count.to_f\n opponents_loss_count = Matchup.where({\"id\" => opponents_matchup_ids}, {\"loser_id\" => i}).count.to_f\n opponents_win_percent = opponents_win_count/(opponents_win_count + opponents_loss_count)\n opponents_win_percentages += opponents_win_percent\n end\n return opponents_win_percentages#/(opponent_ids.count)\n end",
"def get_team_bono_percentage\n total_goals = 0\n total_minimal_goals = 0\n @jugadores.each do |player|\n total_goals += player.goles\n total_minimal_goals += player.nivel.goles_mes\n end\n total_goals / (total_minimal_goals.to_f / 100)\n end",
"def winning_score\n return 0 unless winning_team_game\n winning_team_game.total_score\n end",
"def average_win_percentage(team_id)\n (total_games_won(team_id) / total_games_played(team_id)).round(2)\n end",
"def calculate_owp(games_by_team)\n if games.count > 0\n sum_owp = games.inject(0.0) do |sum, game|\n sked = opponent_schedule game.opponent, games_by_team\n ow = sked.inject(0) { |wins, og| wins + og.wins }\n sum + (sked.empty? ? 0.0 : (ow.to_f / sked.count.to_f))\n end\n @owp = sum_owp / games.count.to_f\n end\n end",
"def average_goals_per_game\n sum = 0.00\n self.games.each_value do |game|\n sum += (game.home_goals + game.away_goals)\n end\n\n (sum / self.games.length).round(2)\n end",
"def win_percent\n win_count = self.get_win_count\n loss_count = self.get_loss_count\n win_percent = (win_count/(win_count + loss_count))\n return win_percent\n end",
"def get_stats(games, team)\n\n team[:wins] = 0\n team[:losses] = 0\n\n games.each do |game|\n\n #Wins and losses if a game is found with the team playing at home...\n if game[:home_team] == team[:team]\n\n game[:home_score].to_i > game[:away_score].to_i ? team[:wins] += 1 : team[:losses] += 1\n\n # or if a game is found with the team playing away.\n elsif game[:away_team] == team[:team]\n\n game[:away_score].to_i > game[:home_score].to_i ? team[:wins] += 1 : team[:losses] += 1\n\n end\n\n end\n\nend",
"def calculate_oowp(all_teams)\n if games.count > 0\n sum_oowp = games.inject(0.0) do |sum, game|\n opponent = all_teams.find { |t| game.opponent.eql? t.team }\n sum + opponent.owp\n end\n @oowp = sum_oowp / games.count.to_f\n end\n end",
"def rounds_won_percentage\n (@rounds_played > 0) ? @rounds_won.to_f / @rounds_played : 0\n end",
"def get_win_percentage(strategy)\n score = 0\n @turns.each do |t|\n score += t.result.to_i if t.strategy.include?(strategy)\n end\n score\n end",
"def hit_percentage\n @hits.to_f / @shots\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns percentage of games an away team has won
|
def percentage_visitor_wins
visitor_wins = @teams.map { |team| team.away_wins }.sum
visitor_games = @teams.map { |team| team.away_games }.sum
(visitor_wins.to_f / visitor_games.to_f).round(2)
end
|
[
"def games_win_percentage(team_id, games)\n total = games.count\n won = 0\n games.each do |game|\n if (team_id == game.away_team_id) && game.outcome.match?(/away win/)\n won += 1\n elsif (team_id == game.home_team_id) && game.outcome.match?(/home win/)\n won += 1\n else\n won += 0\n end\n end\n won.to_f / total\n end",
"def percentage_home_wins\n home_wins = 0\n self.games.each_value do |object|\n if object.home_goals > object.away_goals\n home_wins += 1\n end\n end\n\n (home_wins / (self.games.length).to_f).round(2)\n end",
"def percentage_home_wins\n home_wins = @teams.map { |team| team.home_wins }.sum\n home_games = @teams.map { |team| team.home_games }.sum\n (home_wins.to_f / home_games.to_f).round(2)\n end",
"def calculate_winning_percentage\n games_played = self.won + self.lost\n if games_played == 0\n self.winning_percentage = 0.0\n else\n self.winning_percentage = (self.won*1.0)/games_played\n end\n end",
"def percent_wins(wins)\n ((wins.to_f / @num_games.to_f) * 100).round(4)\n end",
"def win_percent\n matchmade_games < 1 ? 0 : ((total_exp.to_f/matchmade_games.to_f) * 100).to_d\n end",
"def get_team_bono_percentage\n total_goals = 0\n total_minimal_goals = 0\n @jugadores.each do |player|\n total_goals += player.goles\n total_minimal_goals += player.nivel.goles_mes\n end\n total_goals / (total_minimal_goals.to_f / 100)\n end",
"def get_opponents_average_win_percentage\n opponents_win_percentages = 0.0\n opponent_ids = self.get_opponent_ids\n opponents_matchup_ids = self.get_opponents_matchup_ids\n opponent_ids.each do |i|\n opponents_win_count = Matchup.where({\"id\" => opponents_matchup_ids}, {\"winner_id\" => i}).count.to_f\n opponents_loss_count = Matchup.where({\"id\" => opponents_matchup_ids}, {\"loser_id\" => i}).count.to_f\n opponents_win_percent = opponents_win_count/(opponents_win_count + opponents_loss_count)\n opponents_win_percentages += opponents_win_percent\n end\n return opponents_win_percentages#/(opponent_ids.count)\n end",
"def average_goals_per_game\n total_goals = @teams.map {|team| team.total_goals_scored}.sum\n total_games = @teams.map {|team| team.home_games}.sum\n (total_goals.to_f / total_games.to_f).round(2)\n end",
"def average_win_percentage(team_id)\n (total_games_won(team_id) / total_games_played(team_id)).round(2)\n end",
"def winning_score\n return 0 unless winning_team_game\n winning_team_game.total_score\n end",
"def calculate_owp(games_by_team)\n if games.count > 0\n sum_owp = games.inject(0.0) do |sum, game|\n sked = opponent_schedule game.opponent, games_by_team\n ow = sked.inject(0) { |wins, og| wins + og.wins }\n sum + (sked.empty? ? 0.0 : (ow.to_f / sked.count.to_f))\n end\n @owp = sum_owp / games.count.to_f\n end\n end",
"def average_goals_per_game\n sum = 0.00\n self.games.each_value do |game|\n sum += (game.home_goals + game.away_goals)\n end\n\n (sum / self.games.length).round(2)\n end",
"def calculate_oowp(all_teams)\n if games.count > 0\n sum_oowp = games.inject(0.0) do |sum, game|\n opponent = all_teams.find { |t| game.opponent.eql? t.team }\n sum + opponent.owp\n end\n @oowp = sum_oowp / games.count.to_f\n end\n end",
"def rounds_won_percentage\n (@rounds_played > 0) ? @rounds_won.to_f / @rounds_played : 0\n end",
"def winning_team\n if homeTeamPoints.sum > awayTeamPoints.sum\n \"Brooklyn Nets\"\n else\n \"Charlotte Hornets\"\n end\nend",
"def get_win_percentage(strategy)\n score = 0\n @turns.each do |t|\n score += t.result.to_i if t.strategy.include?(strategy)\n end\n score\n end",
"def number_of_outcomes\n @number_of_outcomes ||= (2 ** (self.teams_left)) / 2\n end",
"def winning_team\n brooklyn_players = team_player_info(\"Brooklyn Nets\")\n charlotte_players = team_player_info(\"Charlotte Hornets\")\n\n brooklyn_scores = brooklyn_players.map {|stats|\n stats[:points]}\n\n charlotte_scores = charlotte_players.map {|stats|\n stats[:points]}\n \n brooklyn_total = brooklyn_scores.sum\n charlotte_total = charlotte_scores.sum\n\n charlotte_total > brooklyn_total ? (return charlotte_total) : (return brooklyn_total)\nend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns season with most games played
|
def season_with_most_games
seasons = @games.group_by { |game| game.season }
seasons.max_by { |season, games| games.count }.first
end
|
[
"def season_with_fewest_games\n seasons = @games.group_by { |game| game.season }\n seasons.min_by { |season, games| games.count }.first\n end",
"def last_season\n seasons.max_by { |s| s.index.to_i }\n end",
"def count_of_games_by_season\n games_by_season = @games.group_by { |game| game.season.to_s }\n games_by_season.each { |season, games| games_by_season[season] = games.count }\n end",
"def last_season\n seasons.sort_by{|s| -s[:year]}.first\n end",
"def seasons\n costume_assignments.group(:dance_season).count\n end",
"def most_popular_venue\n venues = @games.group_by { |game| game.venue}\n venues.max_by { |venue, games| games.count }.first\n end",
"def best_season(team_id)\n team_id = team_id.to_i\n team = @teams.select { |each_team| each_team.team_id == team_id }.first\n team.season_win_percentages.max_by { |season, percentage| percentage }.first.to_s\n end",
"def count_of_games_by_season\n output = Hash.new(0)\n\n self.games.each_value do |game|\n output[game.season] += 1\n end\n\n output\n end",
"def games_by_season(set_of_games)\n seasons = set_of_games.group_by do |game|\n game.season\n end\n end",
"def winningest_coach(season)\n coach_win_percentage_hash = coach_win_percentage_helper(season)\n best_win_percentage = 0.0\n best_coach = \"\"\n\n coach_win_percentage_hash.each do |coach, win_percentage|\n if win_percentage > best_win_percentage\n best_win_percentage = win_percentage\n best_coach = coach\n end\n end\n best_coach\n end",
"def retrieve_season_hall_of_fame\n seasons_hall_of_fame = []\n get_involved_teams unless @involved_teams\n\n @involved_teams.each do |team|\n team_placement = {}\n team_placement[:team] = team\n %w[first_place second_place third_place].each_with_index do |rank, index|\n placement = index + 1\n team_placement[rank.to_sym] = team.computed_season_ranking.joins(:season).where(\"seasons.season_type_id = #{@season_type.id} AND computed_season_rankings.rank = #{placement}\").count\n end\n seasons_hall_of_fame << team_placement\n end\n seasons_hall_of_fame.sort { |p, n| (n[:first_place] * 10_000 + n[:second_place] * 100 + n[:third_place]) <=> (p[:first_place] * 10_000 + p[:second_place] * 100 + p[:third_place]) }\n end",
"def worst_season(team_id)\n team_id = team_id.to_i\n team = @teams.select { |each_team| each_team.team_id == team_id }.first\n team.season_win_percentages.min_by { |season, percentage| percentage }.first.to_s\n end",
"def winning_team_game\n self.team_games.sort_by { |team_game| team_game.total_score }.last\n end",
"def worst_coach(season)\n coach_win_percentage_hash = coach_win_percentage_helper(season)\n worst_win_percentage = 2.0\n worst_coach = \"\"\n\n coach_win_percentage_hash.each do |coach, win_percentage|\n if win_percentage < worst_win_percentage\n worst_win_percentage = win_percentage\n worst_coach = coach\n end\n end\n worst_coach\n end",
"def winningest_team\n @teams.max_by { |team| team.total_win_percentage }.team_name\n end",
"def most_tackles(season_id)\n tac_team_id = calclulate_tackles_per_team(season_id).max_by {|t_id, tackles| tackles}[0]\n get_team_name(tac_team_id)\n end",
"def least_popular_venue\n venues = @games.group_by { |game| game.venue}\n venues.min_by { |venue, games| games.count }.first\n end",
"def calculate_most_common_year\n self.calculate_plays_by_year.sort_by{ |year, times_played| times_played }.last\n end",
"def highest_scoring_visitor\n @teams.max_by { |team| team.average_away_goals }.team_name\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns season with fewest games played
|
def season_with_fewest_games
seasons = @games.group_by { |game| game.season }
seasons.min_by { |season, games| games.count }.first
end
|
[
"def season_with_most_games\n seasons = @games.group_by { |game| game.season }\n seasons.max_by { |season, games| games.count }.first\n end",
"def seasons\n costume_assignments.group(:dance_season).count\n end",
"def count_of_games_by_season\n games_by_season = @games.group_by { |game| game.season.to_s }\n games_by_season.each { |season, games| games_by_season[season] = games.count }\n end",
"def games_by_season(set_of_games)\n seasons = set_of_games.group_by do |game|\n game.season\n end\n end",
"def winningest_coach(season)\n coach_win_percentage_hash = coach_win_percentage_helper(season)\n best_win_percentage = 0.0\n best_coach = \"\"\n\n coach_win_percentage_hash.each do |coach, win_percentage|\n if win_percentage > best_win_percentage\n best_win_percentage = win_percentage\n best_coach = coach\n end\n end\n best_coach\n end",
"def count_seasons(date)\n (date.year-2010)*2 + date.two_season - 1\n end",
"def retrieve_season_hall_of_fame\n seasons_hall_of_fame = []\n get_involved_teams unless @involved_teams\n\n @involved_teams.each do |team|\n team_placement = {}\n team_placement[:team] = team\n %w[first_place second_place third_place].each_with_index do |rank, index|\n placement = index + 1\n team_placement[rank.to_sym] = team.computed_season_ranking.joins(:season).where(\"seasons.season_type_id = #{@season_type.id} AND computed_season_rankings.rank = #{placement}\").count\n end\n seasons_hall_of_fame << team_placement\n end\n seasons_hall_of_fame.sort { |p, n| (n[:first_place] * 10_000 + n[:second_place] * 100 + n[:third_place]) <=> (p[:first_place] * 10_000 + p[:second_place] * 100 + p[:third_place]) }\n end",
"def first_season\n seasons.inject { |a, b| a.index.to_i < b.index.to_i && a.index.to_i > 0 ? a : b }\n end",
"def last_season\n seasons.sort_by{|s| -s[:year]}.first\n end",
"def played_matchs_season(round, season = nil)\n count = 0\n matchs = find_matchs(round, season)\n\n matchs.each do |match|\n if match.finished?\n count += 1\n end\n end\n count\n end",
"def worst_season(team_id)\n team_id = team_id.to_i\n team = @teams.select { |each_team| each_team.team_id == team_id }.first\n team.season_win_percentages.min_by { |season, percentage| percentage }.first.to_s\n end",
"def worst_coach(season)\n coach_win_percentage_hash = coach_win_percentage_helper(season)\n worst_win_percentage = 2.0\n worst_coach = \"\"\n\n coach_win_percentage_hash.each do |coach, win_percentage|\n if win_percentage < worst_win_percentage\n worst_win_percentage = win_percentage\n worst_coach = coach\n end\n end\n worst_coach\n end",
"def win_matchs_season(round, season = nil)\n count = 0\n matchs = find_matchs(round, season)\n\n matchs.each do |match|\n if match.is_winner?(self) and match.finished?\n count += 1\n end\n end\n count\n end",
"def count_of_games_by_season\n output = Hash.new(0)\n\n self.games.each_value do |game|\n output[game.season] += 1\n end\n\n output\n end",
"def seasons\n @seasons ||= search_children children\n end",
"def best_season(team_id)\n team_id = team_id.to_i\n team = @teams.select { |each_team| each_team.team_id == team_id }.first\n team.season_win_percentages.max_by { |season, percentage| percentage }.first.to_s\n end",
"def mz_seasons\n age - System::JUNIOR_START_AGE\n end",
"def divisions\n self.division_seasons.select(&:current_season)\n end",
"def actual_seasons(length)\n from = Date.today\n to = from + length\n seasons.select do |s|\n s.min_nights.to_i > 0 &&\n from < s.end_date &&\n s.start_date <= to\n end\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns a hash with season names as keys and counts of games as values
|
def count_of_games_by_season
games_by_season = @games.group_by { |game| game.season.to_s }
games_by_season.each { |season, games| games_by_season[season] = games.count }
end
|
[
"def count_of_games_by_season\n output = Hash.new(0)\n\n self.games.each_value do |game|\n output[game.season] += 1\n end\n\n output\n end",
"def seasons\n costume_assignments.group(:dance_season).count\n end",
"def count_seasons(date)\n (date.year-2010)*2 + date.two_season - 1\n end",
"def played_matchs_season(round, season = nil)\n count = 0\n matchs = find_matchs(round, season)\n\n matchs.each do |match|\n if match.finished?\n count += 1\n end\n end\n count\n end",
"def games_by_season(set_of_games)\n seasons = set_of_games.group_by do |game|\n game.season\n end\n end",
"def average_goals_by_season\n seasons_goals = Hash.new(0.00)\n\n unique_seasons_array_helper.each do |season|\n self.games.each_value do |game|\n seasons_goals[season] += (game.home_goals + game.away_goals) if game.season == season\n end\n end\n\n seasons_goals.merge!(count_of_games_by_season) do |key, oldval, newval|\n (oldval / newval).round(2)\n end\n\n end",
"def sharkStats\n events = queryAPI(\"https://api.sibr.dev/eventually/v2/events?sortorder=desc&type=67&limit=10\")\n events.reduce({\n success: [],\n chorby: [],\n defended: [],\n cannon: [],\n wrestled: []\n }) do |acc, event|\n season = event[\"season\"]\n desc = event[\"description\"]\n if desc.include?(\"DEFENDS\")\n acc[:defended][season] ||= 0\n acc[:defended][season] += 1\n elsif desc.include?(\"CHORBY SOUL\")\n acc[:chorby][season] ||= 0\n acc[:chorby][season] += 1\n elsif desc.include?(\"A CONSUMER\")\n acc[:wrestled][season] ||= 0\n acc[:wrestled][season] += 1\n elsif desc.include?(\"SALMON\")\n acc[:cannon][season] ||= 0\n acc[:cannon][season] += 1\n else\n acc[:success][season] ||= 0\n acc[:success][season] += 1\n end\n acc\n end\nend",
"def retrieve_season_hall_of_fame\n seasons_hall_of_fame = []\n get_involved_teams unless @involved_teams\n\n @involved_teams.each do |team|\n team_placement = {}\n team_placement[:team] = team\n %w[first_place second_place third_place].each_with_index do |rank, index|\n placement = index + 1\n team_placement[rank.to_sym] = team.computed_season_ranking.joins(:season).where(\"seasons.season_type_id = #{@season_type.id} AND computed_season_rankings.rank = #{placement}\").count\n end\n seasons_hall_of_fame << team_placement\n end\n seasons_hall_of_fame.sort { |p, n| (n[:first_place] * 10_000 + n[:second_place] * 100 + n[:third_place]) <=> (p[:first_place] * 10_000 + p[:second_place] * 100 + p[:third_place]) }\n end",
"def seasonal_summary(team_id)\n unique_seasons = []\n\n self.games.each_value do |game|\n unique_seasons << game.season if (game.home_team_id == team_id) || (game.away_team_id == team_id)\n end\n unique_seasons = unique_seasons.uniq\n\n seasonal_summary_hash = Hash.new(0)\n unique_seasons.each do |season|\n # binding.pry\n seasonal_summary_hash[season] = {:postseason =>\n {:win_percentage => season_type_win_percentage_helper(team_id, season, \"Postseason\").round(2),\n :total_goals_scored => season_type_goals_scored_helper(team_id, season, \"Postseason\"),\n :total_goals_against => season_type_goals_against_helper(team_id, season, \"Postseason\"),\n :average_goals_scored => season_type_average_goals_scored_helper(team_id, season, \"Postseason\"),\n :average_goals_against => season_type_average_goals_against_helper(team_id, season, \"Postseason\")\n },\n\n :regular_season =>\n {:win_percentage => season_type_win_percentage_helper(team_id, season, \"Regular Season\").round(2),\n :total_goals_scored => season_type_goals_scored_helper(team_id, season, \"Regular Season\"),\n :total_goals_against => season_type_goals_against_helper(team_id, season, \"Regular Season\"),\n :average_goals_scored => season_type_average_goals_scored_helper(team_id, season, \"Regular Season\"),\n :average_goals_against => season_type_average_goals_against_helper(team_id, season, \"Regular Season\")\n }\n }\n end\n seasonal_summary_hash\n\n end",
"def archetype_counts\n counts = {}\n ids = @replay_outcomes.map(&:archetype_ids).flatten\n ids.each do |arch_id|\n counts[arch_id] ||= 0\n counts[arch_id] += 1\n end\n total_n_games = @replay_outcomes.length\n counts.sort_by {|id, n_games| -n_games }.take(3).map do |id, n_games|\n archetype = Archetype.find_by_archetype_id id\n {\n name: archetype.name,\n path: archetype.path,\n n_games: n_games,\n percent_games: \"%0.2f\" % (n_games * 100.0 / total_n_games),\n }\n end\n end",
"def season_prepare\n ret = {\n :competitions_to_draw => League.all\n }\n \n ret[:competitions_to_draw]\n \n return ret\n end",
"def current_season\n season = nil\n\n { \n winter: [ 12, 1, 2 ], \n spring: [ 3, 4, 5 ], \n summer: [ 6, 7, 8 ],\n fall: [ 9, 10, 11 ]\n \n }.each do |key, range|\n if range.include? current_month\n season = key\n break\n end\n end\n\n season\n end",
"def season\n raw_match['season']\n end",
"def standards_counts\n standards = {}\n standards.default(0)\n\n self.breaches.each do |b|\n standards[b.subject] += 1\n end\n return standards\n end",
"def game_info\n result = {}\n x = 1\n game_hash.each_key do |n|\n g = game_hash[n]\n result[g[:team_name]] = {}\n result[g[:team_name]][:colors] = g[:colors]\n result[g[:team_name]][:pass] = x\n x += 1\n end\n result\nend",
"def goals(season = Season.current_date)\n count = 0\n self.details.goals.each do |detail|\n if detail.season == season\n count += 1\n end\n end\n\n return count\n end",
"def points_season(round, season = nil)\n count = 0\n matchs = find_matchs(round, season)\n\n matchs.each do |match|\n if match.is_winner?(self) and match.finished?\n count += MatchGeneral::PT_WIN\n end\n if match.deal? and match.finished?\n count += MatchGeneral::PT_DEAL\n end\n end\n\n count\n end",
"def top_teams\n plays = self.plays.where(:selection => [\"Favorite\", \"Underdog\"])\n counts = Hash.new(0)\n plays.each do |p|\n p.selection == \"Favorite\" ? \"#{team = p.game.favorite}\" : \"#{team = p.game.underdog}\"\n counts[team] +=1\n puts counts.inspect\n end\n end",
"def month_stats\n @movies.map { |k| k.date.mon }.each_with_object(Hash.new(0)) { |acc, n| n[acc] += 1 }.sort.to_h\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns average number of goals scored in a game across all seasons
|
def average_goals_per_game
total_goals = @teams.map {|team| team.total_goals_scored}.sum
total_games = @teams.map {|team| team.home_games}.sum
(total_goals.to_f / total_games.to_f).round(2)
end
|
[
"def average_goals_by_season\n goals_by_season = @games.group_by { |game| game.season.to_s }\n goals_by_season.each do |season, games|\n season_goals = games.map { |game| game.home_goals + game.away_goals }.sum\n goals_by_season[season] = (season_goals.to_f / games.count.to_f).round(2)\n end\n end",
"def average_goals_by_season\n seasons_goals = Hash.new(0.00)\n\n unique_seasons_array_helper.each do |season|\n self.games.each_value do |game|\n seasons_goals[season] += (game.home_goals + game.away_goals) if game.season == season\n end\n end\n\n seasons_goals.merge!(count_of_games_by_season) do |key, oldval, newval|\n (oldval / newval).round(2)\n end\n\n end",
"def average_goals_per_game\n sum = 0.00\n self.games.each_value do |game|\n sum += (game.home_goals + game.away_goals)\n end\n\n (sum / self.games.length).round(2)\n end",
"def get_average_age_for_season(data, season)\n age_total = 0\n num_of_contestants = 0\n data[season].each do |contestant_hash|\n age_total += (contestant_hash[\"age\"]).to_i\n num_of_contestants += 1\n end\n (age_total / num_of_contestants.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_total = 0\n num_of_contestants = 0\n data[season].each do |description|\n age_total += (description[\"age\"]).to_i\n num_of_contestants += 1\n end\n (age_total / num_of_contestants.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_total = 0\n contestants_total = 0\n data[season].each do |this_contestant|\n age_total += (this_contestant[\"age\"]).to_i\n contestants_total += 1\n end\n (age_total / contestants_total.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_array = []\n age_sum = 0.0\n data[season].each do |contestant|\n age_array << contestant[\"age\"].to_f\n end\n age_array.each do |age|\n age_sum += age\n end\n age_avg = age_sum / age_array.length\n age_avg.round\nend",
"def get_average_age_for_season(data, season)\n num_of_cont = 0\n age_total = 0\n data.each do |season_num, contestants|\n if season_num == season\n contestants.each do |cont_hash|\n num_of_cont += 1\n age_total += cont_hash[\"age\"].to_i\n end\n end\n end\n average = age_total.to_f / num_of_cont.to_f\n average.to_s[3].to_i >= 5 ? average.ceil : average.to_i\nend",
"def seasons\n costume_assignments.group(:dance_season).count\n end",
"def average_win_percentage(team_id)\n all_percents = []\n win_percent_per_season(team_id).each {|season, win_percentage| all_percents << win_percentage}\n all_percents.sum / all_percents.length\n end",
"def average_score all_bowling_games = bowling_games\n total_score = all_bowling_games.reduce(0) { |sum, bowling_game| sum + bowling_game.score }\n total_score / all_bowling_games.length.to_f\n end",
"def avg_assists_per_game\n\t\t#initialize double array\n\t\t\n\t\t\tstats=[]\n\n\t\t\tall_info=@@overall_ranked_stats\n\t\t\tputs @@number_of_champs\n\t\t\ti=0\n\t\t\twhile i<@@number_of_champs.to_i\n\t\t\t\toverallassists= JSON.parse(all_info)['champions'][i]['stats']['totalAssists']\n\t\t\t\ttotal_games=JSON.parse(all_info)['champions'][i]['stats']['totalSessionsPlayed']\n\t\t\t\tavg=overallassists/total_games.to_f\n\t\t\t\t\n\t\t\t\tstats.insert(i,avg)\n\t\t\t\ti=i+1\n\t\t\tend\t\n\t\t\treturn stats\n\t\t\n\tend",
"def count_of_games_by_season\n games_by_season = @games.group_by { |game| game.season.to_s }\n games_by_season.each { |season, games| games_by_season[season] = games.count }\n end",
"def get_average_age_for_season(data, season)\n age_array =[]\n data[season].each do |participant_hash| # participant hash is an array\n age_array << participant_hash[\"age\"].to_i\n end\n # age_array.inject { |sum, i| avg = ((sum + i) / data[season].size) }\n (age_array.reduce(:+).to_f / data[season].size).round\n # the error was literally a rounding error\nend",
"def goals_against_season(round, season = nil)\n count = 0\n matchs = find_matchs(round, season)\n\n matchs.each do |match|\n count += match.goals_against(self) if match.finished?\n end\n\n count\n end",
"def seasonal_score\n score = 0\n ingredients.each do |ingr|\n score += ingr.seasonal\n end\n max = ingredients.count * 2\n (score * 100 / max)\n # puts \"--------------\"\n # puts \"recipe: #{title}\"\n # puts \"score #{score} / #{max}\"\n end",
"def goals(season = Season.current_date)\n count = 0\n self.details.goals.each do |detail|\n if detail.season == season\n count += 1\n end\n end\n\n return count\n end",
"def total_score_for_game(game)\n Round.where(team: self, game: game).map(&:score).sum\n end",
"def avg_damage_taken_per_game\n\t\t#initialize double array\n\t\t\n\t\t\tstats=[]\n\n\t\t\tall_info=@@overall_ranked_stats\n\t\t\tputs @@number_of_champs\n\t\t\ti=0\n\t\t\twhile i<@@number_of_champs.to_i\n\t\t\t\toverallhurt= JSON.parse(all_info)['champions'][i]['stats']['totalDamageTaken']\n\t\t\t\ttotal_games=JSON.parse(all_info)['champions'][i]['stats']['totalSessionsPlayed']\n\t\t\t\tavg=overallhurt/total_games.to_f\n\t\t\t\t\n\t\t\t\tstats.insert(i,avg)\n\t\t\t\ti=i+1\n\t\t\tend\t\n\t\t\treturn stats\n\t\t\n\tend"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns a hash with season names as keys and average goals that season as a value
|
def average_goals_by_season
goals_by_season = @games.group_by { |game| game.season.to_s }
goals_by_season.each do |season, games|
season_goals = games.map { |game| game.home_goals + game.away_goals }.sum
goals_by_season[season] = (season_goals.to_f / games.count.to_f).round(2)
end
end
|
[
"def average_goals_by_season\n seasons_goals = Hash.new(0.00)\n\n unique_seasons_array_helper.each do |season|\n self.games.each_value do |game|\n seasons_goals[season] += (game.home_goals + game.away_goals) if game.season == season\n end\n end\n\n seasons_goals.merge!(count_of_games_by_season) do |key, oldval, newval|\n (oldval / newval).round(2)\n end\n\n end",
"def get_average_age_for_season(data, season)\n age_total = 0\n num_of_contestants = 0\n data[season].each do |contestant_hash|\n age_total += (contestant_hash[\"age\"]).to_i\n num_of_contestants += 1\n end\n (age_total / num_of_contestants.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_total = 0\n num_of_contestants = 0\n data[season].each do |description|\n age_total += (description[\"age\"]).to_i\n num_of_contestants += 1\n end\n (age_total / num_of_contestants.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_total = 0\n contestants_total = 0\n data[season].each do |this_contestant|\n age_total += (this_contestant[\"age\"]).to_i\n contestants_total += 1\n end\n (age_total / contestants_total.to_f).round(0)\nend",
"def get_average_age_for_season(data, season)\n age_array = []\n age_sum = 0.0\n data[season].each do |contestant|\n age_array << contestant[\"age\"].to_f\n end\n age_array.each do |age|\n age_sum += age\n end\n age_avg = age_sum / age_array.length\n age_avg.round\nend",
"def count_of_games_by_season\n output = Hash.new(0)\n\n self.games.each_value do |game|\n output[game.season] += 1\n end\n\n output\n end",
"def get_average_age_for_season(data, season)\n age_array =[]\n data[season].each do |participant_hash| # participant hash is an array\n age_array << participant_hash[\"age\"].to_i\n end\n # age_array.inject { |sum, i| avg = ((sum + i) / data[season].size) }\n (age_array.reduce(:+).to_f / data[season].size).round\n # the error was literally a rounding error\nend",
"def get_average_age_for_season(data, season)\n num_of_cont = 0\n age_total = 0\n data.each do |season_num, contestants|\n if season_num == season\n contestants.each do |cont_hash|\n num_of_cont += 1\n age_total += cont_hash[\"age\"].to_i\n end\n end\n end\n average = age_total.to_f / num_of_cont.to_f\n average.to_s[3].to_i >= 5 ? average.ceil : average.to_i\nend",
"def seasons\n costume_assignments.group(:dance_season).count\n end",
"def seasonal_summary(team_id)\n unique_seasons = []\n\n self.games.each_value do |game|\n unique_seasons << game.season if (game.home_team_id == team_id) || (game.away_team_id == team_id)\n end\n unique_seasons = unique_seasons.uniq\n\n seasonal_summary_hash = Hash.new(0)\n unique_seasons.each do |season|\n # binding.pry\n seasonal_summary_hash[season] = {:postseason =>\n {:win_percentage => season_type_win_percentage_helper(team_id, season, \"Postseason\").round(2),\n :total_goals_scored => season_type_goals_scored_helper(team_id, season, \"Postseason\"),\n :total_goals_against => season_type_goals_against_helper(team_id, season, \"Postseason\"),\n :average_goals_scored => season_type_average_goals_scored_helper(team_id, season, \"Postseason\"),\n :average_goals_against => season_type_average_goals_against_helper(team_id, season, \"Postseason\")\n },\n\n :regular_season =>\n {:win_percentage => season_type_win_percentage_helper(team_id, season, \"Regular Season\").round(2),\n :total_goals_scored => season_type_goals_scored_helper(team_id, season, \"Regular Season\"),\n :total_goals_against => season_type_goals_against_helper(team_id, season, \"Regular Season\"),\n :average_goals_scored => season_type_average_goals_scored_helper(team_id, season, \"Regular Season\"),\n :average_goals_against => season_type_average_goals_against_helper(team_id, season, \"Regular Season\")\n }\n }\n end\n seasonal_summary_hash\n\n end",
"def sharkStats\n events = queryAPI(\"https://api.sibr.dev/eventually/v2/events?sortorder=desc&type=67&limit=10\")\n events.reduce({\n success: [],\n chorby: [],\n defended: [],\n cannon: [],\n wrestled: []\n }) do |acc, event|\n season = event[\"season\"]\n desc = event[\"description\"]\n if desc.include?(\"DEFENDS\")\n acc[:defended][season] ||= 0\n acc[:defended][season] += 1\n elsif desc.include?(\"CHORBY SOUL\")\n acc[:chorby][season] ||= 0\n acc[:chorby][season] += 1\n elsif desc.include?(\"A CONSUMER\")\n acc[:wrestled][season] ||= 0\n acc[:wrestled][season] += 1\n elsif desc.include?(\"SALMON\")\n acc[:cannon][season] ||= 0\n acc[:cannon][season] += 1\n else\n acc[:success][season] ||= 0\n acc[:success][season] += 1\n end\n acc\n end\nend",
"def count_of_games_by_season\n games_by_season = @games.group_by { |game| game.season.to_s }\n games_by_season.each { |season, games| games_by_season[season] = games.count }\n end",
"def gross_per_studio(collection)\n result = {}\n i = 0\n while i < collection.size do\n studio = collection[i][:studio]\n total_earnings = collection[i][:worldwide_gross]\n if !result[studio]\n result[studio] = total_earnings\n else\n result[studio] += total_earnings\n end\n i += 1\n end\n \n # GOAL: Given an AoH where each Hash is a movie, return a Hash that includes\n # the total worldwide_gross of all the movies from each studio.\n #\n # INPUT: (collection) AoH where each Hash represents a movie\n #\n # RETURN: Hash where the keys are the studios and the values are the sum of\n # all the worldwide_gross numbers for every movie in the input Hash\n \n result\nend",
"def song_average(beyonce)\n hit_average_hash = {}\n beyonce[:hits].each do |hit|\n hit_average_hash[hit[:title]] = [\"Song fierceness: #{hit[:fierceness]}\", \"Total average fierceness: #{average_fierceness(beyonce)}\"]\n end\n hit_average_hash\nend",
"def games_by_season(set_of_games)\n seasons = set_of_games.group_by do |game|\n game.season\n end\n end",
"def average_goals_per_game\n total_goals = @teams.map {|team| team.total_goals_scored}.sum\n total_games = @teams.map {|team| team.home_games}.sum\n (total_goals.to_f / total_games.to_f).round(2)\n end",
"def avg_assists_per_game\n\t\t#initialize double array\n\t\t\n\t\t\tstats=[]\n\n\t\t\tall_info=@@overall_ranked_stats\n\t\t\tputs @@number_of_champs\n\t\t\ti=0\n\t\t\twhile i<@@number_of_champs.to_i\n\t\t\t\toverallassists= JSON.parse(all_info)['champions'][i]['stats']['totalAssists']\n\t\t\t\ttotal_games=JSON.parse(all_info)['champions'][i]['stats']['totalSessionsPlayed']\n\t\t\t\tavg=overallassists/total_games.to_f\n\t\t\t\t\n\t\t\t\tstats.insert(i,avg)\n\t\t\t\ti=i+1\n\t\t\tend\t\n\t\t\treturn stats\n\t\t\n\tend",
"def current_season\n season = nil\n\n { \n winter: [ 12, 1, 2 ], \n spring: [ 3, 4, 5 ], \n summer: [ 6, 7, 8 ],\n fall: [ 9, 10, 11 ]\n \n }.each do |key, range|\n if range.include? current_month\n season = key\n break\n end\n end\n\n season\n end",
"def average_goals_per_game\n sum = 0.00\n self.games.each_value do |game|\n sum += (game.home_goals + game.away_goals)\n end\n\n (sum / self.games.length).round(2)\n end"
] |
{
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
returns total number of teams
|
def count_of_teams
@teams.count
end
|
[
"def team_count\n @teams.length\n end",
"def num_total_teams_possible\n count = 0\n self.owned_participant_registrations.each do |pr|\n count = count + pr.num_novice_local_teams\n count = count + pr.num_experienced_local_teams\n count = count + pr.num_novice_district_teams\n count = count + pr.num_experienced_district_teams\n end\n return count\n end",
"def team_count(division)\n total = 0\n teams.each do |team|\n total = total + 1 if !team.division.nil? and team.division.name == division\n end\n total\n end",
"def number_of_teams\n unless user.team_member_count\n errors.add(:base, 'Team limit has been reached!')\n end\n end",
"def get_total_games_played\n return games.size\n end",
"def num_district_teams\n num_teams = 0\n novice_division = Division.find_by_name('District Novice')\n experienced_division = Division.find_by_name('District Experienced')\n teams.each do |team|\n if team.division == novice_division or team.division == experienced_division\n if team.team_registration.complete?\n num_teams += 1\n end\n end\n end\n num_teams\n end",
"def total_wins(team)\n wins = 0\n match_winners.each do |winner|\n if winner == team.name\n wins += 1\n end\n end\n return [wins, team.name]\n end",
"def get_total_games_played\n\t\treturn games.size\n\tend",
"def number_of_outcomes\n @number_of_outcomes ||= (2 ** (self.teams_left)) / 2\n end",
"def team_members_count_target(project)\n members_count = 0\n members_count = project.team.slots\n members_count\n end",
"def total_rounds(teams_count)\n Util.padded_teams_even_count(teams_count) - 1\n end",
"def total_team_goals(equipo)\n @team.select { |player| player[:equipo] == equipo }.sum {|h| h[:goles].to_i }\n end",
"def local_experienced_count\n team_count('Local Experienced')\n end",
"def team_size\n if teams.size > number_of_teams\n errors[:tournament] << \"There cannot be more teams than specified number.\"\n end\n end",
"def total_rounds(driver)\n Algorithm::RoundRobin.total_rounds(driver.seeded_teams.length)\n end",
"def total_team_score(teams_id)\n total_score = 0\n @league_data.each do\n |team| \n # binding.pry\n if team.home_team_id == teams_id\n total_score += team.home_team_score\n elsif team.away_team_id == teams_id\n total_score += team.away_team_score\n end\n end\n return total_score\n end",
"def top_teams\n plays = self.plays.where(:selection => [\"Favorite\", \"Underdog\"])\n counts = Hash.new(0)\n plays.each do |p|\n p.selection == \"Favorite\" ? \"#{team = p.game.favorite}\" : \"#{team = p.game.underdog}\"\n counts[team] +=1\n puts counts.inspect\n end\n end",
"def number_of_same_teams(match_type)\n matches = Match.where(match_type: match_type + 1, score_board_id: self.id)\n main = ScoreBoard.main_score_board\n matches_official = Match.where(match_type: match_type, score_board_id: main.id)\n teams_of = []\n teams = []\n count = 0\n\n if matches_official.empty?\n matches_official = main.calculate_proper_matches(match_type)\n end\n matches_official.each do |match_official|\n teams_of << match_official.teams\n end \n matches.each do | match |\n teams << match.teams\n end\n teams_of.flatten!\n teams.flatten!\n teams_of.each do | team_of|\n if teams.include?(team_of)\n count += 1\n end\n end\n return count\n end",
"def update_competetion_teams\n competetion.update(no_of_teams: competetion.teams.count)\n end"
] |
{
"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.